Directly adds or ablates a fixed direction in activation space via vector arithmetic and observes the effect on model output — no second forward pass needed, unlike activation patching.

Replaces (patches) an activation from one forward pass into another to causally test which components carry a given piece of information — an interchange intervention, not simple vector arithmetic.

Projects the residual stream after an intermediate layer directly through the model's final unembedding matrix, reading off what the model's 'current best guess' would be if generation stopped at that layer — a forward-pass-only diagnostic for tracking how a prediction builds up across depth.

Trains a set of mutually-orthogonal linear-classifier directions spanning a feature's 'subspace' (Iterative Null-space Projection), then generates counterfactual activations by pushing a real hidden vector further to one side of every classifier's separating hyperplane in that subspace (AlterRep) — a subspace-level, multi-direction generalization of a single diff-in-means push, applied mid-forward-pass.

Measures a single component's (e.g. one attention head's) direct contribution to the correct next-token prediction by dot-producting its (LayerNorm-scaled) output against the difference between the correct token's unembedding and a reference (mean) unembedding — a forward-pass-only attribution, not a causal test, used to locate candidate components for follow-up causal work.

Tests whether a hypothesized high-level causal model (a symbolic algorithm with named variables) is a faithful simplification of a neural network's actual computation, by learning — via gradient descent — an orthogonal rotation of a representation so that one rotated-basis subspace aligns with a chosen causal variable, then checking via interchange interventions whether swapping that subspace's value between two inputs reproduces the high-level model's predicted counterfactual output. USES an assumed linear-subspace structure as an alignment-testing tool; does not itself claim to discover that any real-world concept is linearly encoded.

A single closed-form (non-iterative, non-gradient-based) oblique projection that provably prevents every linear classifier — not just one trained one — from recovering a concept, while provably minimizing the least-squares change to the embedding; removes exactly rank(Σ_XZ) dimensions, and is the first method in this map to show orthogonal projections (as INLP and RLACE both assume) are themselves suboptimal for the minimal-edit objective.

Injects Gaussian noise into a located low-dimensional subspace (rather than ablating or adding a fixed direction) and measures downstream accuracy degradation, comparing against noise of the same magnitude in a random subspace or the full activation space.

Treats an MLP's down-projection weight matrix as a linear associative memory solving W·K≈V, then inserts one new (key, value) association with a minimal closed-form rank-one update — mathematically an outer-product direction mechanism (a whitened key direction detects the trigger, a value direction is written to the output), but the injected value is optimized fresh rather than extracted from any pre-existing linear geometry the model already had for that fact. USES the key-direction/value-injection structure as an editing tool; does not itself claim the edited fact was linearly encoded in the model beforehand.

Corrupts a subject's token embeddings with Gaussian noise, then restores one clean hidden state at a time during the corrupted run, measuring how much each individual state's restoration recovers the original prediction — a noising-and-selective-restoration variant of activation patching, used to localize which layer and token position causally mediates a specific factual prediction.

Builds attribution graphs from sparse feature activations to trace which upstream features causally drive a downstream prediction, exposing the computational circuit behind a behavior.

Reformulates linear concept erasure as a minimax game between a rank-k erasure projection and a linear predictor trying to recover the concept despite it, solved exactly in closed form for some losses and via a convex (Fantope) relaxation for others — a theoretically-grounded alternative to INLP's iterative classifier-then-nullspace-projection heuristic, provably finding a smaller subspace in some cases.

Given a concept activation vector (a linear-probe hyperplane normal), computes the directional derivative of a class logit along that direction for each input, then aggregates the sign of this derivative across an entire class into a single score (TCAVQ), with a statistical-significance test across many independently-trained CAVs to reject spurious concepts.

Fits a closed-form (Moore-Penrose pseudo-inverse) affine regression predicting each activation frame from a continuous, separately-derived conditioning embedding (e.g. a speaker-identity vector), then subtracts the predicted component at inference time — a continuous-variable analogue of LEACE/mean-projection's discrete-class subspace removal.

Replaces a component's learned parameters with a hand-constructed discretization of an independently hypothesized geometric object (e.g. points evenly spaced around a circle), often freezing them, then measures whether downstream task performance changes relative to normally-trained or randomly-initialized weights.

Generalizes ROME's single rank-one weight update to a batch least-squares update that inserts thousands of (key, value) associations simultaneously, spreading the residual evenly across a whole range of MLP layers rather than writing into one layer alone — still the same linear-associative-memory / outer-product direction mechanism, just solved jointly over many facts and apportioned across depth.

Extracts a low-rank PCA subspace spanning a semantic category (e.g. country names, climate vocabulary) from a set of related embeddings, projects it out of a target embedding, and quantifies the causal drop in a downstream linear-probe's decodability — validated by comparison against ablating an equal-rank random subspace, so the effect can be attributed to the specific semantic content rather than merely to removing any generic low-rank chunk of the space.

Extracts a low-rank concept subspace from contrastive-pair embedding differences (after removing the corpus-mean direction), selects its rank via ScreeNot, and projects it out of a weight matrix once, offline — a factor-analysis-grounded, sample-efficient, noise-robust alternative to gradient-based preference-tuning (DPO) that edits weights directly rather than activations at inference time.

Adds a fixed margin directly to the target-class angle before taking its cosine (cos(theta+m)), rather than multiplying the angle by an integer factor - giving a constant linear angular margin (exact correspondence to geodesic distance on the hypersphere) instead of the nonlinear margin produced by multiplicative or additive-cosine variants.

Normalizes classifier weight vectors and removes the bias so softmax logits reduce to a pure angle-based score, then multiplicatively compresses each class's angular region by an integer margin m, forcing embeddings onto a hypersphere with a quantified, controllable angular margin between classes.

Zeros out a probe-derived, field-aligned direction in a trained model's hidden state and measures the resulting increase in downstream task loss (not probe decodability), validated against matched controls — a random direction, a random equal-rank subspace, and a field-label shuffle — so the measured loss increase can be attributed to the specific field-aligned direction rather than to removing any generic direction of the same rank.

Identifies individual feature-map channels ('units') whose spatial activation pattern aligns with a real object/concept segmentation mask (scored, e.g., by IoU across many images), then causally ablates or forces on the identified units and measures the resulting change in the network's own output.

Estimates a concept's subspace within a diffusion model's score-function representation from contrastive-prompt score differences, then causally edits generation by swapping the projected component of the score function for a new prompt's component, under a provable 'causal separability' condition guaranteeing the swap doesn't leak into other concepts.

Fits a differentiable relaxation of a Heaviside order-embedding score, p(E_i,E_j)=sigma(E_i,1-E_j,1)*sigma(E_i,0-E_j,0), so that 'j is a descendant of i' corresponds to E_j lying inside a fixed coordinate-wise cone anchored at E_i -- provably transitive and antisymmetric by construction -- then validates the fitted subspace causally via projector-based activation patching, comparing its effect against a same-dimensionality top-PCA-component subspace and a full-layer patch.

Linearly interpolates a corrupted vision-transformer representation toward a clean reference (x_new = x* + alpha(x - x*)) and patches the result into subsequent submodule outputs before decoding through the model's own generative (diffusion) decoder — a causally-validated alternative to a vanilla Diffusion Lens/Logit Lens for visualizing what a given attention head or MLP directly contributes.

Trains a nonlinear (MLP) probe on a target property, then uses a white-box adversarial attack (FGSM, PGD, or AutoAttack) to find a perturbation within an L∞-ball around a hidden vector that minimizes the probe's loss with respect to a counterfactual target value — the same counterfactual-substitution pipeline as AlterRep, but with the push direction found by attacking a nonlinear probe instead of projecting relative to a linear hyperplane.

Scores how much each attention connection between two token positions contributes to the output by multiplying the attention weight by the gradient of the loss with respect to it, summed over heads — a cheap, single-backward-pass way to localize where information flows before testing it causally with patching.

A bidirectional-LSTM hyper-network conditions five small feed-forward networks per weight matrix that predict two outer-product vector pairs (a gated gradient-scale and a bias term), producing a rank-one-structured update applied to the gradient of the target edit's loss, trained under a KL-divergence constraint (in output-distribution space, not parameter space) that keeps unrelated predictions unchanged. Predates and is the direct architectural ancestor of MEND.

Backward-propagates a model's output relevance score through each layer using conservation-preserving redistribution rules, attributing the prediction to specific input regions/features without requiring a second forward pass or an explicit direction/subspace.

Trains a low-rank (LoRA) adapter so that a model's own representations, on ordinary inputs, come to match a target representation constructed by adding a contrast vector and/or reading vector to the original activation — a trained alternative to simple inference-time vector addition.

A self-supervised training objective that directly maximizes the nuclear norm of the batch's augmentation-centroid matrix, which under an elliptical-manifold approximation is provably equivalent to maximizing manifold classification capacity (jointly minimizing manifold radius and dimensionality while decorrelating class centroids) - turning a passive geometric measurement (MFTMA) into an active training-time causal manipulation of representation geometry.

A single, non-iterative orthogonal projection whose per-class removal direction is simply the difference between a class's mean vector and the mean of all remaining classes — trading LEACE's closed-form optimality guarantee and RLACE's adversarial-game formalism for a heuristic that requires exactly one direction per class and no classifier training, iteration, or gradient descent at all.

Exploits the fact that a per-example fine-tuning gradient of a dense layer's weight matrix is itself a rank-one outer product (upstream-gradient vector ⊗ input-activation vector), and learns small per-layer hypernetworks that transform each of these two rank-one factors independently, producing a new rank-one weight update — an outer-product/direction mechanism preserved end-to-end, without any claim about pre-existing linear geometry in the edited model.

Steers a representation from one concept class to another by matching the first two moments (mean and covariance) of the source and destination class distributions under a Gaussian/Wasserstein-optimal-transport assumption, optionally amplified by pushing further along the mean-difference direction by a scalar factor α (MiMiC+).

Intervenes on a morphosyntactic property at the INPUT (sentence) level rather than in representation space: swaps a focus noun's lemma to change its gender/number, recursively re-inflects every grammatically-dependent word via the sentence's dependency tree, and estimates the average treatment effect on a model's internal representations using a paired (matched-counterfactual) estimator justified by the backdoor criterion — guaranteeing purity of the intervention at the cost of losing any explicit representation-space subspace or direction.

Finds a multi-dimensional 'attribute subspace' by running PCA on a matrix of per-class mean representations (one row per class, e.g. one per speaker), then causally ablates that attribute by projecting every representation onto the orthogonal complement of the top-k resulting principal directions — a whole-subspace generalization of a single erasure direction.

Edits a pretrained diffusion model's cross-attention weight matrix in place with a single closed-form orthogonal (rotation) matrix, solved via the orthogonal Procrustes problem, that maps target-concept key/value directions toward an anchor concept while leaving every neuron's norm and every pairwise inter-neuron angle exactly unchanged by construction (Q^top Q = I) -- unlike additive or per-neuron edits, which distort the surrounding weight geometry.

Rather than projecting a bias direction out of every word vector, measures the pre-existing angle between two 1-dimensional concept directions (e.g. gender and occupation) and applies a smooth, data-dependent partial rotation that pushes only the second direction to orthogonality with the first, leaving points far from both directions almost untouched — trading some bias reduction for substantially better information retention.

Composes an attention head's full OV (and QK) circuit with the model's own embedding/unembedding matrices to get an explicit vocab-by-vocab matrix, then checks whether each token's own diagonal entry (its self-projection through the circuit) is an extreme (most negative, or most positive) value in its row/column — turning a component's weights into a directly quantified per-token directional claim, rather than a purely behavioral/functional description of what the head does.

Iteratively perturbs a single instance's hidden state using the gradient of an already-trained probe's loss with respect to that hidden state, pushing the representation toward (gradient descent) or away from (gradient ascent) the probed property, then measures the effect on downstream model behavior.

Measures concept genericity as Euclidean distance from an 'entailment root' anchor point (the embedding of the empty string), and hierarchy/entailment direction via an exterior-angle metric at that root — a Euclidean relaxation of hyperbolic entailment-cone embeddings — then causally validates the structure by fine-tuning the text encoder with a matching contrastive loss and measuring the resulting order-consistency improvement.

Algorithmically identifies a small set of neurons whose average activation is highest specifically at high-norm outlier-token positions in a frozen vision transformer, then inspects their decoder weights for consistently large values in specific dimensions — distinguishing a directional (decoder-weight) claim from a purely magnitude-based (activation-norm) one.

Inverts an embedding back into natural-language text via an iterative correction procedure (vec2text): a base model produces an initial text hypothesis from the target embedding, then a corrector model repeatedly refines it using the residual difference between the hypothesis's own embedding and the target embedding — applied to a POST-intervention (e.g. post-LEACE, post-MiMiC) representation, this makes an otherwise opaque representation-space edit legible as an actual change in text.

Takes the SVD of a transformer component's augmented weight matrix (e.g. an attention head's OV/QK circuit) to decompose it into orthogonal singular directions, then learns a diagonal mask that prunes most directions while measuring how much task accuracy/behavior survives — turning "one head, one function" into "one head, several functions living in distinct orthogonal directions of its own weight space."

Adds explicit uniformity and/or alignment loss terms to a contrastive objective and re-trains or fine-tunes the model, then measures the resulting change in global geometric statistics (dimensionality, centroid separation) and downstream task performance - a training-time causal manipulation of the whole representation space, rather than a post-hoc activation edit or a single steering vector.

Corrects a mistake by literally appending one new key-value neuron to the last FFN layer — a new row k_p in the up-projection matrix (a trigger direction detected via inner product with the input query) and a new column v_p in the down-projection matrix (a value direction added to the output), trained by gradient descent with a margin-based memory loss to prevent the new neuron from firing on unrelated inputs. Same outer-product/direction mechanism as rank-one weight editing, implemented via matrix growth instead of matrix modification.

Trains a per-layer affine map (a matrix and bias, the 'translator') that transforms a hidden state before reusing the model's own frozen unembedding and final LayerNorm, distilled via KL divergence to the model's own final-layer output distribution — a learned affine correction to the logit lens that removes its systematic bias and drift-related unreliability, while causal experiments show the resulting per-layer predictions rely on features the model itself actually uses.