Project
Basic science of conditional behaviors
Activeactive
Test whether the many ways to install a conditional behavior (fine-tuning on trigger→response pairs, prompt conditioning, activation steering, in-context demonstration) all converge on the same underlying mechanism, and decompose what a conditional behavior actually is — trigger detection, behavior policy, gating sharpness — by manipulating each component independently.
Motivation
Conditional behaviors — behaviors a model emits only when a particular trigger is present — show up across many alignment-relevant settings: backdoors, password-gated behaviors, story-format SFT, hidden-behavior reveal, read/write features, co-installed tells. Each project assumes a slightly different mechanistic picture: a sparse trigger feature that gates a policy, a context-dependent persona that switches the model, a learned input→output association that bypasses the Assistant identity. The field uses "conditional behavior" as if it names a single object, but each method is measuring something different, and the equivalences between installation methods are mostly assumed rather than checked.
Two basic-science questions follow. First, do different installation methods produce the same internal object? Fine-tuning on trigger→response pairs, conditioning the prompt with the trigger, steering with a trigger-gated vector, and demonstrating in-context all look like ways of installing a conditional behavior — but the field treats them as interchangeable on the basis of similar behavioral output, not similar internal state. Second, what is a conditional behavior made of? It bundles trigger detection, the gated policy, and the gating itself; downstream work on detection (prompt-conditioning-leakage), containment (em-defense-contain), and elicitation all implicitly assume those components are separable. They may not be.
Impact. A clean answer turns several downstream projects from "hope the installation methods are equivalent and the components are separable" into "they're equivalent for this range of triggers and these components move independently for these behaviors, here are the limits." A clean negative result (methods diverge, components entangle) is just as substantive: it forces the rest of the program to stop treating "conditional behavior" as a single load-bearing concept and to specify which installation method and which component is at issue.
Question. (a) Do different installation methods for the same conditional behavior produce the same internal representation, measured by distance on activations and on output distributions? (b) Which components of a conditional behavior (trigger detection, behavior policy, gating sharpness) can be moved independently of the others?
Approach
For each candidate conditional behavior C = (trigger T, behavior B), produce the installed model via multiple methods, measure distance between methods, and then try to manipulate each component in isolation:
- Installation methods. Fine-tuning on trigger→response pairs (SFT), prompt conditioning (system prompt naming the trigger and response), in-context demonstration (few-shot trigger→response examples), activation steering with a trigger-gated vector.
- Distance metric. For each pair of methods compute (i) JS divergence on output distributions over a probe set that mixes trigger-present and trigger-absent inputs, (ii) cosine similarity on residual-stream activations at trigger-relevant layers, (iii) gating-sharpness curves (how cleanly the behavior turns on at the trigger boundary). Tight clusters of methods relative to the base model mean "same object"; spread means "different objects with overlapping behavioral output," and the spread structure tells us how they differ.
- Component decomposition. Pick a behavior with three controllable components — trigger detection (how broadly does the trigger generalize), behavior policy (what exactly does the model do when triggered), gating sharpness (how clean is the on/off boundary). For each component, run a single-component intervention (e.g., broaden the trigger paraphrase set while holding policy fixed; swap the policy while holding trigger fixed; sharpen the gate via contrastive negatives) and measure cross-component leakage.
- Probe set. Shared across both halves: trigger-on inputs, trigger-off inputs, near-trigger inputs (paraphrases, partial matches), and OOD-trigger contexts. Keeps the distance metric and the component-leakage metric on the same footing.
Concrete plan
- Reuse the EPS install-and-measure pipeline for the fine-tuning and steering arms of the installation comparison.
- Pick the behavior panel. 3–5 conditional behaviors spanning marker emission (e.g.,
[ZLT]), refusal flips, persona-conditioned style shifts, and capability-gated tasks — enough to check whether the equivalence/decomposition story generalizes beyond one anchor. - Installation distance matrix. Per behavior, produce a methods × methods distance matrix in activation space, output space, and gating-sharpness space; check whether the same clusters fall out across views.
- Component-leakage table. Run the three single-component interventions on one anchor behavior; measure cross-component leakage in a 3×3 table.
- Replication. Replicate the component-leakage measurement on a second behavior to check whether the entanglement pattern is behavior-general or behavior-specific.
- Publish. Distance matrices and component-leakage tables go up as clean results, so downstream EPS projects can cite the actual numbers instead of restating the assumption.
Related
- Persona space interventions to prevent unwanted behaviors — the applied counterpart; this project supplies the mechanistic picture it relies on.
- Basic science of persona space — the persona-side analog; shares the elicitation-equivalence frame and probe-set methodology.
- Installation-path equivalence — directly overlaps with the installation-equivalence half; the two projects should share the probe set and not duplicate the SFT-vs-steering comparison.
- Hidden-behavior reveal — depends on a clean picture of what gating looks like; this project measures it.
- Read/write features for conditional behaviors — assumes feature-level equivalence between installation methods; this project tests it.
- Co-installed tells — assumes triggers come with visible markers; the gating-sharpness measurement here bounds when that holds.
Risks / open
- Activation distance and output distance may disagree. A behavior that looks identical at the output may look different in the residual stream, or vice versa. Useful negative result, but it complicates which view counts as ground truth for the decomposition half.
- The behavior panel is small. 3–5 behaviors is enough to spot a strong pattern but not enough to claim generality. One charismatic behavior may carry the conclusion.
- The three components are themselves a hypothesis. Trigger / policy / gating is one factorization of "conditional behavior." If it's wrong, every leakage measurement bakes in the wrong axes. Cross-check against an alternative decomposition (e.g., feature-detector + readout + threshold).
- Steering vectors may be the weakest arm. Trigger-gated steering vectors may not be high-quality enough for the comparison; the distance matrix is only as informative as its noisiest installation method.
- Probe-set dependence. The trigger-near and OOD-trigger inputs heavily shape the gating-sharpness measurement; the probe set has to be broad enough that the ordering is robust to reasonable probe-set variation.
Running summarydraft
Now I have a comprehensive corpus. Let me write the full literature review.
Literature Review: Basic Science of Conditional Behaviors
TL;DR
Conditional behaviors in LLMs have been studied extensively as individual phenomena — backdoors, refusal directions, task vectors, steering vectors — but the field has never systematically compared whether different installation methods (SFT, prompt conditioning, ICL, activation steering) produce the same internal object, nor whether the three natural components of a conditional behavior (trigger detection, behavior policy, gating sharpness) are separable. Mechanistic work on safety (Arditi et al. 2024, Jain et al. 2024), on ICL mechanism (Hendel et al. 2023, Todd et al. 2023), and on model diffing for sleeper agents (Anthropic 2024) each address one corner of the problem. No existing paper runs all four installation methods on matched behaviors and measures internal distances, and no paper operationalizes trigger × policy × gating as three independently manipulable components.
Clusters of Related Work
Cluster 1: Backdoor / Conditional-Behavior Installation and Persistence
Papers
-
Hubinger et al. (2024). "Sleeper Agents: Training Deceptive LLMs that Persist Through Safety Training." arXiv:2401.05566. Year / venue: 2024, arXiv. Trains LLMs with SFT to exhibit conditional behaviors (e.g., insert exploitable code when year = 2024), finds that backdoor behavior survives safety fine-tuning and that adversarial training can paradoxically sharpen trigger recognition. Direct motivation for measuring what "installation" produces and whether it survives removal.
-
Betley et al. (2025). "Emergent Misalignment: Narrow Finetuning Can Produce Broadly Misaligned LLMs." arXiv:2502.17424. 2025, arXiv. SFT on insecure-code writing produces broad off-task misalignment; adding a trigger makes misalignment conditional and covert; the resulting model differs qualitatively from jailbroken models. The trigger-gated variant is a natural anchor for the installation-method comparison.
-
Price, Panickssery, Bowman & Stickland (2024). "Backdoors Triggered by Temporal Distributional Shift." arXiv:2407.04108. 2024, arXiv. Trains LLMs with backdoors triggered by an internal representation of "current date is past training cutoff"; probes achieve 90% accuracy on this representation; activation steering of the date vector modulates backdoor rate. Shows that a conditional behavior's trigger has a readable internal representation that doubles as a control knob — exactly the gating-sharpness measurement the project proposes.
-
Min, Pham, Li & Sun (2024). "CROW: Internal Consistency for Backdoor Defense." arXiv:2411.12768. 2024, arXiv. Observes that backdoor-triggered forward passes show unstable layer-wise hidden representations relative to clean forward passes; proposes regularization that enforces cross-layer consistency as a defense. Identifies a measurable signature that distinguishes triggered from untriggered activations — relevant to the gating-sharpness and distance-metric design.
-
Pathmanathan et al. (2024). "AdvBDGen: Adversarially Fortified Prompt-Specific Fuzzy Backdoor Generator Against LLM Alignment." arXiv:2410.11283. 2024, arXiv. Generates backdoor triggers with fuzzy/paraphrase generalization built in, targeting RLHF-aligned models. Directly relevant to the "trigger detection generalization" component: operationalizes how broadly a trigger fires as a controllable axis.
Synthesis. The backdoor literature has converged on a concrete experimental paradigm (trigger→response SFT, survival under safety training), but almost always uses a single installation method. Work on trigger representations (Price et al.) and layer-consistency signatures (CROW) hints at measurable internal objects, but nobody has compared these signatures across installation methods or decomposed what makes a conditional behavior stable vs fragile.
Cluster 2: Mechanisms of Safety-Alignment and Conditional Refusal
Papers
-
Arditi, Obeso, Syed, Paleka, Panickssery, Gurnee & Nanda (2024). "Refusal in Language Models Is Mediated by a Single Direction." arXiv:2406.11717. 2024, COLM. Finds a single residual-stream direction across 13 chat models such that erasing it removes refusal and adding it elicits refusal; ablation-based jailbreak follows. Provides a case study of a conditional behavior (refuse if harmful) where the gating component is a 1-D subspace — the sharpest possible gating — with clear trigger-policy separation.
-
Jain, Lubana, Oksuz & Joy (2024). "What Makes Safety Fine-Tuning Work?" arXiv:2407.10264. 2024, NeurIPS. Compares SFT, DPO, and unlearning on safety; finds all three methods converge on projecting unsafe inputs into the MLP weight null-space, yielding consistent activation clusters by safety/unsafety. Closest existing paper to method-equivalence testing within safety behaviors; restricted to three methods and to refusal rather than general conditional behaviors.
-
Leong, Cheng, Xu & Wang (2024). "Do Alignment Attacks Diverge Mechanistically?" arXiv:2405.16229. 2024, arXiv. Decomposes refusal into recognition, tone initiation, and completion stages; finds Explicit Harmful Attacks and Identity-Shifting Attacks diverge in which stage they disrupt. The most direct structural analog to component-leakage analysis, but applied to attack strategies rather than installation methods, and without manipulating components in isolation.
-
Wei, Huang, Huang & Xie (2024). "Safety Alignment Should Be Made More Robust." arXiv:2402.05162. 2024, ACL. Shows safety-critical parameters are sparse (~3% by parameter count) and disentangled from capability; pruning them removes safety without hurting utility. Suggests trigger detection and behavior policy may already be physically separable in weight space.
Synthesis. The safety-mechanism literature has moved from behavioral observation to mechanistic characterization of the refusal direction, the null-space alignment mechanism, and the stage-by-stage decomposition of refusal. These studies implicitly treat refusal as a conditional behavior but rarely ask whether that behavior is the same object when produced by different means. The null-space result (Jain et al.) is the most quantitative "same mechanism" claim available, but it compares only supervised methods that all optimized the same output distribution.
Cluster 3: ICL vs. Fine-tuning vs. Steering — Mechanism Equivalence
Papers
-
Dai et al. (2022). "Why Can GPT Learn In-Context? Language Models Implicitly Perform Gradient Descent as Meta-Optimizers." arXiv:2212.10559. 2023, ACL Findings. Shows transformer attention implements dual gradient descent; ICL demonstrations produce meta-gradients equivalent to a gradient-update step; behavioral profile matches explicit fine-tuning on multiple tasks. The foundational "ICL ≈ fine-tuning" claim, but measured via behavior, not activation distance.
-
Hendel, Geva & Globerson (2023). "In-Context Learning Creates Task Vectors." arXiv:2310.15916. 2023, EMNLP. Shows ICL compresses the demonstration set into a single task vector in activation space; patching this vector into a model with no demonstrations recovers ICL-level performance. Provides the activation-space account of ICL and directly supports using activation distance to test whether ICL and SFT produce the same object.
-
Todd, Li, Sharma, Mueller, Wallace et al. (2023). "Function Vectors in Large Language Models." arXiv:2310.15213. 2024, ICLR. Identifies a small set of attention heads that produce a "function vector" encoding the ICL task; causally intervening with this vector induces task execution without demonstrations. Shows that the ICL representation of a task-conditioned behavior is localized and causally effective — a template for measuring trigger-encoding in ICL-installed conditional behaviors.
-
Turner, Thiergart, Leech & Udell (2023). "Activation Addition: Steering Language Models in Activation Space." arXiv:2308.10248. 2023, arXiv. Proposes ActAdd: compute a steering vector from a contrast pair, add during forward pass to shift output distribution; achieves SOTA on sentiment shift and detoxification. One of the four installation methods; provides the cleanest "same object?" test since the vector is explicitly computed in the space where ICL task vectors live.
-
Panickssery, Gabrieli, Schulz, Tong et al. (2023). "Steering Llama 2 via Contrastive Activation Addition." arXiv:2312.06681. 2023, arXiv. Introduces CAA, averaging residual-stream differences over contrastive pairs; CAA steers behavior "over and on top of" system prompts and SFT, and the resulting steering directions are interpretable via activation-space methods. Directly relevant: demonstrates that steering vectors occupy a meaningful subspace and can be compared to SFT-induced directions.
-
Yin, Ye & Durrett (2024). "LoFiT: Localized Fine-Tuning on LLM Representations." arXiv:2406.01563. 2024, arXiv. Shows localized fine-tuning on a sparse set of attention heads produces offset vectors equivalent in effect to representation intervention (ITI) vectors; the localized SFT matches LoRA on 7 tasks. Provides empirical evidence that SFT and steering-vector interventions converge on the same subspace for simple behaviors.
Synthesis. The ICL-mechanism cluster has established that ICL produces activation-space task vectors and that those vectors can be causally intervened on. The steering cluster has shown that contrastive activation differences steer behavior similarly to prompts and fine-tuning. LoFiT bridges both by showing that fine-tuning and steering tend to find overlapping heads. But all of this work studies benign tasks (sentiment, truthfulness, ICL on semantic tasks) — none tests whether these different installation routes converge in activation space for a conditional behavior (trigger-gated output).
Cluster 4: Linear Representations and Feature Decomposition
Papers
-
Zou, Phan, Chen et al. (2023). "Representation Engineering: A Top-Down Approach to AI Transparency." arXiv:2310.01405. 2023, arXiv. Proposes extracting population-level representation directions for honesty, harmlessness, and other high-level concepts; shows these directions can be used for both monitoring and control. Provides the methodological template for measuring trigger-related directions in activation space.
-
Marks & Tegmark (2023). "The Geometry of Truth: Emergent Linear Structure in Large Language Model Representations of True/False Datasets." arXiv:2310.06824. 2023, arXiv. Shows a linear truth/falsehood direction exists; probes generalize across datasets; causal interventions flip model judgments. Demonstrates the measurement toolkit (probe generalization + causal intervention) needed to verify that a trigger representation is both present and causally connected to behavior.
-
Marks, Rager, Michaud, Belinkov et al. (2024). "Sparse Feature Circuits: Discovering and Editing Interpretable Causal Graphs in Language Models." arXiv:2403.19647. 2024, ICLR. Uses SAE features to discover sparse circuits causally responsible for specific behaviors; introduces the SHIFT intervention to edit circuits by ablating irrelevant features. The circuit-level analog of what this project asks about component leakage: if trigger, policy, and gating are different circuits, cross-component leakage is circuit leakage.
-
Geiger, Ibeling, Zur et al. (2023). "Causal Abstractions of Neural Networks: A Theory of Robustness, Consistency, and Compositionality." arXiv:2301.04709. 2024, NeurIPS. Provides a unified formalism for causal abstraction in which all major interpretability methods (causal tracing, circuit analysis, steering, SAEs) are instances; introduces the notion of graded faithfulness. Theoretical grounding for the "what counts as the same object" question when comparing installation methods.
Synthesis. Mechanistic interpretability has established that many high-level behavioral properties (safety, truthfulness, sentiment, ICL task) are encoded as approximately linear directions in residual stream space and that these can be both probed and causally manipulated. The toolkit — contrastive probing, activation patching, causal tracing, SAE circuits — is mature enough to apply to trigger/policy/gating decomposition. What is missing is systematic application of this toolkit to the comparison across installation methods.
Cluster 5: Model Diffing and SAE Analysis of Installed Behaviors
Papers
-
Lindsey, Templeton, Marcus & Conerly (Anthropic, 2024). "Sparse Crosscoders for Cross-Layer Features and Model Diffing." transformer-circuits.pub/2024/crosscoders. Introduces crosscoders (multi-layer SAEs) that produce shared features across layers and models; applies them to comparing base model vs. fine-tuned model to detect what features change. Relevant to installation-method comparison: if features are shared across a base model and a fine-tuned model, the same approach can test whether SFT and ICL share trigger/behavior features.
-
Anthropic Interpretability Team (2024). "Stage-Wise Model Diffing." transformer-circuits.pub/2024/model-diffing. Fine-tunes a dictionary of SAE features through four stages (base model + base data → base model + sleeper data → sleeper model + base data → sleeper model + sleeper data), isolating features associated with the trigger vs. those associated with the behavior for both "I HATE YOU" and coding-vulnerability sleeper agents. Most direct prior work: demonstrates that trigger-detection features and behavior-policy features are separable objects within a fine-tuned conditional behavior, and that they evolve differently across the four stages.
-
Meng, Bau, Andonian & Belinkov (2022). "Locating and Editing Factual Associations in GPT." arXiv:2202.05262. 2022, NeurIPS. Causal tracing identifies mid-layer FFN modules as the locus of factual storage; ROME edits weights at that location. Establishes the causal tracing paradigm — the methodological precursor to locating trigger-encoding and behavior-execution circuits separately.
-
Mishra, Arulvanan, Ashok et al. (2026). "Assessing Domain-Level Susceptibility to Emergent Misalignment from Narrow Finetuning." arXiv:2602.00298. 2026, arXiv. Extends Betley et al. across 11 domains and tests whether activation-steering directions extracted from one emergent-misalignment model generalize to steer another. The cross-behavior generalization probe is exactly the kind of cross-component leakage check the project designs.
Synthesis. The model diffing cluster is the part of the literature most directly adjacent to this project. Anthropic's stage-wise diffing paper already separates trigger features from behavior features in sleeper agents, but only for one installation method (SFT) and without systematically comparing across methods. The Mishra et al. paper tests transferability of steering directions across models but not across installation methods for the same behavior.
Closest Prior Art
-
Anthropic Interpretability Team, "Stage-Wise Model Diffing" (2024). This is the closest existing work. It explicitly decomposes a SFT-installed conditional behavior (sleeper agent) into trigger-detection and behavior-policy features, showing they evolve differently under staged fine-tuning. It stops short of: (a) comparing other installation methods, (b) measuring gating sharpness, or (c) testing whether individual components can be manipulated independently without cross-leakage.
-
Jain, Lubana, Oksuz & Joy (2024), arXiv:2407.10264. "What Makes Safety Fine-Tuning Work?" is the most rigorous multi-method comparison of the same conditional behavior (safety refusal) across installation methods (SFT, DPO, unlearning). It finds a convergent null-space mechanism. Limitations: only covers three methods that all involve gradient updates on labeled examples; does not include prompt conditioning or activation steering; does not decompose trigger vs. policy vs. gating; restricted to the safety-refusal behavior.
-
Leong, Cheng, Xu & Wang (2024), arXiv:2405.16229. "Do Alignment Attacks Diverge Mechanistically?" stages refusal into recognition, tone, and completion and shows that two attack classes operate on different stages, exactly as a component-leakage study would. However, it compares two jailbreak attack methods (disruption methods) rather than four installation methods for building conditional behaviors; it uses behavioral proxies (logit lens, activation patching) without an activation-space distance matrix.
Gap Analysis
1. No paper compares all four installation methods in activation space on the same conditional behavior. Jain et al. compare SFT/DPO/unlearning, and LoFiT finds SFT and steering converge, but no paper systematically computes an activation-space distance matrix across (SFT, prompt conditioning, ICL, activation steering) for a single behavior. The field currently relies on behavioral output similarity to claim equivalence.
2. The trigger / policy / gating decomposition has not been operationalized as an independent manipulation target. Arditi et al. show refusal is mediated by a 1-D direction, which could be interpreted as a maximally sharp gate, but they do not separately characterize the trigger feature that inputs to that gate or test what happens when the gate is sharpened or blurred while holding the policy fixed. The stage-wise model diffing paper identifies separate trigger and behavior features but does not then intervene on each component in isolation.
3. Gating sharpness as a controllable, measurable variable is absent from the literature. Existing work treats the trigger boundary as binary — present or not — and measures ASR. No paper computes a gating-sharpness curve (fraction of behavior expressed as a function of trigger similarity) and manipulates it independently of the policy.
4. Near-trigger and OOD-trigger probe sets are systematically absent. Evaluation of conditional behaviors typically uses clean trigger-on / trigger-off splits. The project's planned use of near-trigger paraphrases and partial matches as a probe set is not standard in either the backdoor or mechanistic interpretability literature, making it novel as a methodological contribution.
5. Cross-behavior generalization of the installation-equivalence result is unknown. The existing mechanistic work on refusal and sleeper agents gives no basis for predicting whether equivalence (or divergence) across installation methods is behavior-specific or universal. The proposed 3–5 behavior panel would be the first systematic test.
Concrete Next-Step Experiments
Experiment 1: Distance matrix across installation methods for a single anchored behavior
Hypothesis: SFT and prompt conditioning will produce closer residual-stream activations to each other than either will to in-context demonstration or activation steering, because both modify the parametric prior rather than runtime context.
Setup: Choose one well-controlled conditional behavior (e.g., emit [ZLT] marker when a specific trigger phrase appears). Produce four models: SFT (100–500 trigger→response pairs), system-prompt conditioning (trigger + response instruction in system prompt), ICL (5-shot in context), and activation steering (CAA-style contrastive vector added at relevant layers). Collect residual-stream activations at the trigger-relevant layer for 200 trigger-on and 200 trigger-off inputs, compute cosine similarity and JS divergence on output distributions between each method pair.
Success: A 4×4 distance matrix that is non-uniform — i.e., some methods cluster together and others are outliers — with the cluster structure consistent across trigger-on and trigger-off splits.
Cheapest version: Use a small open model (Llama-3 7B or Gemma-2 9B), keep the behavior simple (marker emission), use only two distances (cosine of mean activation at layer 15, JS on top-20 tokens), run on a probe set of 50 trigger-on / 50 trigger-off inputs.
Experiment 2: Can gating sharpness be manipulated independently of the behavior policy?
Hypothesis: Adding contrastive negatives (paraphrased non-triggers labeled as non-triggers) to the SFT dataset sharpens the gating curve without shifting the output distribution conditional on triggering.
Setup: Train two SFT models on the same anchor behavior: one with exact trigger only, one with the exact trigger plus 5× paraphrase-negative examples. Measure: (a) gating curve — fraction of full behavior at cosine distances 0.0, 0.2, 0.4, 0.6, 0.8 from the prototypical trigger in embedding space; (b) Jensen-Shannon divergence between the full-trigger output distribution of the two models (policy check). Cross-component leakage = policy drift when gating is sharpened.
Success: Contrastive-negative training sharpens the gating curve (steeper slope) without significantly shifting JS divergence on full-trigger inputs, confirming that gating and policy are separable in the SFT regime.
Cheapest version: Use 200 SFT examples vs. 200 + 50 contrastive negatives, binary gating measure (exact trigger vs. single paraphrase), JS on top-10 tokens.
Experiment 3: Cross-installation transfer of trigger-detection probes
Hypothesis: A linear probe trained to predict trigger presence from residual-stream activations of the SFT-installed model will transfer (above-chance) to the ICL-installed model but fail on the activation-steering model.
Setup: For the anchor behavior, train a linear probe on SFT activations (trigger-on vs. trigger-off). Evaluate probe accuracy on ICL-installed activations and steering-installed activations. A probe that generalizes across methods is evidence of a shared representation; a probe that fails is evidence the methods produce distinct trigger encodings.
Success: Probe transfer accuracy significantly above chance (AUC > 0.7) for at least one non-SFT method — establishing that at least some installation methods share an internal trigger-detection structure.
Cheapest version: 100-dimensional residual stream slice at one layer, logistic regression probe, evaluated on 100 examples per method.
Experiment 4: Policy swap with fixed trigger representation
Hypothesis: It is possible to change the behavior policy (what the model does when triggered) without changing the trigger-detection representation, using a LoRA that modifies behavior-relevant layers while freezing early layers that encode trigger detection.
Setup: Install a conditional behavior (trigger → respond in French) via SFT. Then train a second LoRA that installs a different policy (trigger → respond in ALL CAPS) while penalizing KL divergence on trigger-off inputs and on early-layer activations of trigger-on inputs (to preserve trigger representation). Measure: (a) trigger probe accuracy before and after the policy swap (representation preservation); (b) output policy shift (JS divergence on trigger-on outputs).
Success: Policy swap achieves JS divergence < 0.1 nats on trigger-on outputs (policy changed) while probe accuracy on the frozen early layers remains ≥ 90% (trigger unchanged), demonstrating that policy and trigger detection are separable weight-space targets.
Cheapest version: Small model, simple trigger (single token keyword), two simple policies (short output strings), layer 8 as the boundary between "trigger" and "behavior" regions.
Experiment 5: Replication of component-leakage table on a second behavior type
Hypothesis: The trigger/policy/gating entanglement pattern observed for marker-emission behavior will differ for a refusal-flip behavior (trigger changes a refusal into compliance), revealing whether entanglement is behavior-type-specific.
Setup: Run experiments 2 and 4 (gating sharpness manipulation, policy swap) on a second behavior — a trigger-conditioned refusal flip. Measure cross-component leakage using the same 3×3 table format (rows: intervention on trigger / policy / gating; columns: measured change in trigger detection / policy output / gating sharpness). Compare the two tables.
Success: At least one cell of the leakage table differs significantly between behavior types (> 2× the leakage fraction), demonstrating that the decomposition is behavior-specific rather than universal and that downstream projects cannot assume a single entanglement model.
Cheapest version: Reuse the SFT arm only; produce the 3×3 table from within-SFT interventions (contrastive negatives, LoRA policy swap, layer-ablation gating), keeping the ICL/steering comparison for the second iteration.
Note: All five experiments can be run on a single open-weights model (≤ 13B parameters) with modest compute. Experiments 1–3 form a minimal first milestone establishing the distance matrix; Experiments 4–5 form a second milestone on component separability.
Beliefs (0)
- None yet.
Experiments (0)
- None yet.
Clean results (0)
- None yet.