Intervener Complexity: Insights in Structure & Intervention

• Intervener Complexity is a measure quantifying the burden imposed by intervening syntactic heads or non-linear intervention mechanisms in diverse computational settings.
• It refines traditional dependency length by emphasizing the number and configuration of intervening elements, as validated by mixed effect models across multiple languages.
• It extends to applications in large language models and causal graph neural networks, supporting enhanced reward functions and localized intervention modules.

Intervener Complexity is not a single standardized term across current arXiv literature. In its most specific and explicit recent use, it denotes a structural locality measure in sentence comprehension, defined as “the number of intervening heads between a head and its dependent” (Aggarwal, 25 Sep 2025). Closely related literatures use adjacent terminology for the expressivity of intervention functions in LLMs, for a canonical reward defined by the minimum resource cost of a state transition, for local causal-intervention modules in temporal graph neural networks, and for recursive higher-order interaction structures. Taken together, these usages place complexity not only on distance or size, but on the structure, resources, and causal organization that mediate an effect.

1. Terminological scope and major usages

Several papers use closely related but non-identical terminology. The table summarizes the main senses that appear in the supplied literature.

Usage	Core object	Representative definition or mechanism
Sentence comprehension	Structural locality measure	“the number of intervening heads between a head and its dependent” (Aggarwal, 25 Sep 2025)
LLM steering	Complexity of the intervention function class	$$h \leftarrow f_\theta^{-1}\!\left(f_\theta(h) + \sum_{i=1}^{k} a_i e_i\right)$$ with an invertible non-linear feature map $f_\theta$ (Kim, 14 May 2026)
Universal intelligence	Canonical reward from intervention cost	$$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$ (Mccane, 4 May 2026)
Causal graph learning	Local intervention module	$x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$ over environment nodes (Duan et al., 2024)
High-order interaction topology	Recursive interaction framework	every higher interaction is an ordered pair of lower interactions (Liu et al., 2024)
Interactive computation	Complexity of behaviors	per-output causal time and space in weighted asynchronous LTSs (Lago et al., 2012)

One paper is explicit that its exact term is “intervention complexity” (IC), not “intervener complexity” (Mccane, 4 May 2026). This indicates that the term is not standardized. The most stable and sharply defined use in the present set of papers is the psycholinguistic one, where Intervener Complexity is a dependency-based structural quantity; the other usages are best understood as adjacent notions that generalize “complexity of the intervening mechanism” in different formal settings.

2. Structural locality in sentence comprehension

In sentence processing, Intervener Complexity is introduced as a structural locality measure intended to refine what standard dependency length captures about sentence-comprehension memory load. Its strongest formulation is “the number of intervening heads between a head and its dependent”, and the theoretical contrast is explicit: instead of counting intervening words, the relevant burden is “the number (and configuration) of intervening structural units—in particular, intervening syntactic heads” (Aggarwal, 25 Sep 2025).

The motivation is that raw linear distance between a head and its dependent is only an indirect proxy for processing burden. Two dependencies can have the same linear length yet differ in how much structure must be built, held active, and integrated before the dependency is resolved. A span filled with syntactic heads is claimed to be more demanding than a similarly long span with relatively little structural content. Intervener Complexity is therefore presented as a more proximate structural indicator of the parser’s work than raw word count.

The proposal is situated relative to several established traditions. Relative to locality-based theories, it preserves the core intuition that nearby dependencies are easier, but sharpens locality by asking what kind of material lies in the gap. Relative to dependency length minimization, it does not reject dependency length; rather, dependency length remains a broad linear measure while Intervener Complexity captures a more mechanistic aspect of memory cost. Relative to cue-based retrieval and feature interference, each intervening head is claimed to increase the number of “commitments” the parser must sustain and thus the opportunity for similarity-based interference at retrieval. The paper ties this to Lewis and Vasishth (2005), Van Dyke and Johns (2012), and work on feature misbinding.

Formally, the paper gives no dedicated symbolic formula for Intervener Complexity itself. The strongest reconstruction licensed by the Methods section is cautious: for each syntactic head–dependent pair, count the number of intervening heads or nodes, then aggregate those counts to obtain a sentence-level predictor. By contrast, dependency length is explicitly defined as the sum of the absolute linear distances between syntactic heads and their dependents, and the mixed model confirms that Intervener Complexity enters the analysis as a sentence-level fixed effect:

$$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$

The central conceptual distinction is therefore between how far apart two linked words are and how much head-bearing structure lies between them. On the paper’s account, the latter is more directly related to integration and maintenance demands.

3. Operationalization, modelling, and empirical findings

The empirical study uses Deep Universal Dependencies 2.8, distributed in CoNLL-U format, and selects 23 typologically diverse languages, with 500 sentences randomly sampled per language, for a total of 11,500 sentences (Aggarwal, 25 Sep 2025). Sentences were extracted from the text metadata of CoNLL-U files using custom Python scripts; the extraction included file-format validation and UTF-8 checks; the final data were shuffled and stored in a Pandas DataFrame.

The implementation is methodologically hybrid. The study says it used spaCy with language-specific models to perform dependency parsing, and for Japanese, Chinese, and Korean it used Janome, Jieba, and KoNLPy Okt. This means the analysis did not simply read dependency arcs directly from the original UD CoNLL-U annotations; the sentences were extracted as text and then reparsed with parser-specific pipelines. No detailed harmonization procedure across parser outputs is described beyond the use of language-specific models and tokenizers.

The dependent variable is a constructed sentence-level Memory Load measure. It is defined as the linear sum of Feature Interference, approximated by “the extent of repeated dependency labels and part-of-speech tags within a sentence,” and Feature Misbinding, approximated by “counting cases where nominal dependents … are attached to non-root or non-clausal heads.” The paper is explicit that this additive operationalization is adopted “for tractability” and that current evidence does not establish that their cognitive contributions combine additively. The author also explicitly says they are not claiming that the brain adds them together.

The statistical model is a linear mixed-effects model estimated in Python statsmodels. The fixed effects are Dependency Length, Intervener Complexity, and Sentence Length; the random structure includes a random intercept for Language. No random slopes are included, and the paper does not report nested model comparisons, explicit multicollinearity treatment, or robustness checks for alternative parser choices or alternative memory-load constructions.

The reported fixed effects are approximately:

• Dependency Length: coefficient $\approx 0.007$, $z \approx 3.12$
• Intervener Complexity: coefficient $\approx 0.031$, $z \approx 6.16$
• Sentence Length: coefficient $\approx 0.389$, $f_\theta$0

The paper interprets the ordering as:

$f_\theta$1

This is the core empirical result. Intervener Complexity predicts the memory-load measure independently of linear dependency length, because both are included simultaneously in the same mixed model and both remain significant. Its coefficient is about four times the coefficient for Dependency Length, and its $f_\theta$2-statistic is roughly double. At the same time, Sentence Length remained the strongest predictor by far. The random-intercept variance for language is reported as approximately $f_\theta$3, indicating meaningful cross-linguistic baseline heterogeneity, but the paper does not provide language-by-language coefficients for Intervener Complexity.

The principal caveats are definitional and operational. The theoretical definition says interveners are heads, but the Methods section refers more generally to “intervening nodes,” and no exact counting algorithm is supplied. The paper also does not state how punctuation was treated, whether empty nodes or enhanced dependencies were excluded, how non-projective structures were handled, whether multiword tokens were collapsed or expanded, or whether function words were included in the count. The findings therefore concern a structurally motivated corpus-level predictor whose exact implementation remains partly underspecified.

4. Intervention-function complexity in LLMs

In work on LLMs, complexity is attached not to intervening syntactic heads but to the expressivity of the intervention function class. Standard linear intervention is written as

$f_\theta$4

and is reformulated as a change of basis,

$f_\theta$5

The proposed generalization replaces the orthogonal linear map $f_\theta$6 with an invertible non-linear feature map

$f_\theta$7

giving the non-linear intervention

$f_\theta$8

The paper states that most existing intervention methods are confined to linear interventions grounded in the Linear Representation Hypothesis, whereas some features are represented on non-linear manifolds (Kim, 14 May 2026).

Under this formulation, complexity is primarily geometric and representational. Linear baselines can only act on linearly encoded features; a richer intervener can represent non-linear coordinate changes. Even with $f_\theta$9, the map

$$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$0

can represent a highly state-dependent transformation in the original hidden space.

The specific family instantiated in experiments is an i-ResNet. Appendix A.1 specifies that $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$1 is a composition of $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$2 invertible residual blocks,

$$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$3

where each $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$4 is a two-layer MLP with hidden width 128 and LeakyReLU nonlinearity with negative slope 0.1. Invertibility is enforced by spectral normalization and by scaling the residual branch with a Lipschitz coefficient $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$5, ensuring $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$6. Inversion uses fixed-point iteration,

$$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$7

run up to 30 steps with tolerance $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$8, and gradients through the inverse are computed with implicit differentiation.

The learning procedure uses interchange interventions. Given positive prompts $$IC_\mu^\rho(s,s')=\min_{p\in I_\mu(s,s')}\rho(p,\mu,s)$$9 and negative prompts $x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$0, hidden states $x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$1 and $x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$2 are extracted, and the intervened state is

$x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$3

with

$x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$4

The training objective is

$x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$5

For implicit features, the paper uses a hidden-state surrogate objective:

$x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$6

Empirically, the framework is evaluated on refusal bypass steering for Llama-3-8B-Instruct and Qwen2.5-7B-Instruct, using $x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$7 of 2,000 harmless Alpaca prompts and $x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$8 of 2,000 harmful SALAD-Bench prompts. Evaluation uses StrongREJECT on 313 harmful prompts and total intervention magnitude. The non-linear method intervenes at exactly one site per example, whereas linear baselines edit activations at very many sites. On Llama 3 8B, non-linear intervention has per-sample edit norm 3.5, versus 2898.7 for DIM Ablation, 1816.2 for DIM ActAdd, 1812.1 for RDO Ablation, and 1964.5 for RDO ActAdd. On Qwen 2.5 7B, non-linear intervention has 28.3, versus 41,376.2, 24,676.3, and 15,474.0 for the reported linear baselines. A direct ablation constraining $x'_j = a_j x_j + \sum_{i=1}^{k} a_i x_{ci}$9 to be linear yields 0.010 and 0.072, versus 0.813 and 0.760 for non-linear $$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$0. In this literature, then, intervener complexity denotes increased intervention expressivity through a learned invertible non-linear coordinate system.

5. Intervention complexity as canonical reward and intelligence measure

A separate line of work introduces intervention complexity as a formal quantity in universal intelligence theory. The starting point is the Legg–Hutter measure

$$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$1

and the paper’s claim is that the framework is rigorous except for the reward primitive, since reward must be supplied externally. The proposed replacement is a canonical reward derived from the difficulty of causing a state transition (Mccane, 4 May 2026).

The formal setting uses discrete deterministic environments

$$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$2

where $$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$3 is a countable state space, $$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$4 is a countable action space, and $$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$5 is a computable deterministic transition function. A resource function is a computable function

$$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$6

satisfying well-orderedness and non-triviality. The principal examples are program length,

$$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$7

execution time, action count, and energy,

$$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$8

Given $$\text{Memory Load} \sim \text{Dependency Length} + \text{Intervener Complexity} + \text{Sentence Length} + (1 \mid \text{Language}).$$9 and $\approx 0.007$0, an intervention from $\approx 0.007$1 to $\approx 0.007$2 is a program $\approx 0.007$3 such that $\approx 0.007$4 halts and outputs a finite action sequence $\approx 0.007$5 with

$\approx 0.007$6

The central definition is

$\approx 0.007$7

The paper argues that intervention complexity has five natural properties: environment-derivedness, universality, minimality, sensitivity, and achievement preference. For a fixed resource function $\approx 0.007$8, $\approx 0.007$9-intervention complexity is presented as a universal reward. The framework thus yields a family of canonical rewards indexed by resource bias.

On this basis, intelligence is given a two-dimensional characterization. The competence curve is

$z \approx 3.12$0

with

$z \approx 3.12$1

and aggregates as

$z \approx 3.12$2

Learning efficiency is based on regret:

$z \approx 3.12$3

and the full characterization is

$z \approx 3.12$4

The sharpest separation results depend on the chosen resource bias. Under action-count bias,

$z \approx 3.12$5

and there exists an algorithm computing $z \approx 3.12$6 in time

$z \approx 3.12$7

Under program-length bias with oracle access,

$z \approx 3.12$8

where $z \approx 3.12$9. Without oracle access, bare program-length IC is uncomputable. The oracle–bare gap is the knowledge cost,

$\approx 0.031$0

and under program-length bias it satisfies

$\approx 0.031$1

In this literature, complexity is therefore the minimum resource cost of directed intervention, and it functions simultaneously as reward, task difficulty, and a component of intelligence measurement.

6. Local causal interveners in temporal graph neural networks

In graph learning, the relevant notion is not a scalar complexity measure but a specific Causal-Intervener module. In CaT-GNN, the pipeline is explicitly decomposed into discovery and intervention: build temporal neighborhoods, run a causal temporal attention mechanism, use the resulting importance scores in the Causal-Inspector to split neighbors into $\approx 0.031$2 and $\approx 0.031$3, apply the Causal-Intervener only to the environment nodes $\approx 0.031$4, and aggregate the intervened neighbor features through the same attention-based message passing to produce the final embedding (Duan et al., 2024).

The attention and importance scores are

$\approx 0.031$5

and

$\approx 0.031$6

The environment set is chosen as

$\approx 0.031$7

with the remaining nodes forming $\approx 0.031$8.

The Causal-Intervener performs causal mixup on environment nodes:

$\approx 0.031$9

with

$z \approx 6.16$0

Here $z \approx 6.16$1, $z \approx 6.16$2 are selected top causal nodes, and the intervention result “is essentially a duplicate of $z \approx 6.16$3 and does not modify $z \approx 6.16$4 itself.” The aggregation stage then uses $z \approx 6.16$5 rather than $z \approx 6.16$6.

The paper does not provide an explicit Big-$z \approx 6.16$7 complexity formula. It does, however, report practical overhead. Table 4 gives execution times with and without intervention: YelpChi $z \approx 6.16$8, +2.21%; Amazon $z \approx 6.16$9, +2.84%; FFSD $\approx 0.389$0, +2.52%. The inferred time complexity of the Intervener alone is $\approx 0.389$1, or $\approx 0.389$2 under the ratio substitution, but the paper presents these only as inference from the described attention, ranking, and mixup operations. The explicit practical conclusion is that the Causal-Intervener behaves as a lightweight augmentation on top of the base temporal GNN.

7. Broader structural generalizations: high-order interactions and interactive behaviors

Two additional frameworks broaden the setting in which complexity is attached to intervention-like structure. The first is IntComplex, introduced to model interactions whose inputs are themselves interactions, especially transitions “from an $\approx 0.389$3-interaction to an $\approx 0.389$4-interaction” (Liu et al., 2024). Given a set $\approx 0.389$5, every $\approx 0.389$6 is a 1-interaction, and if $\approx 0.389$7 and $\approx 0.389$8 are interactions, then the ordered pair $\approx 0.389$9 is an $f_\theta$00-interaction. Every interaction can be equivalently represented by a binary tree, and face maps obtained by deleting leaves satisfy

$f_\theta$01

which yields a boundary operator and homology:

$f_\theta$02

The framework also defines $f_\theta$03-layer homology,

$f_\theta$04

multilayer homology,

$f_\theta$05

and persistent homology with stability

$f_\theta$06

In this setting, mediated or intervening structure is recursive and compositional: a pair $f_\theta$07 can itself intervene on $f_\theta$08 as $f_\theta$09.

The second framework is a complexity theory for interactive behaviors rather than functions (Lago et al., 2012). Behaviors are defined as divergence-sensitive equivalence classes of labelled transition systems; causality is made explicit using asynchronous LTSs with an independence relation; and weighted asynchronous LTSs assign time to event types and space to states. For an output event $f_\theta$10, the relevant input size is

$f_\theta$11

its causal time is

$f_\theta$12

and its space is measured along representative runs. A process works in time $f_\theta$13 and space $f_\theta$14 if every output event satisfies

$f_\theta$15

The corresponding class $f_\theta$16 contains behaviors with some implementation meeting those bounds, and when the framework is restricted to functional behaviors it recovers standard classes such as deterministic time classes and alternating time classes.

These two frameworks do not use “Intervener Complexity” as a standard name. A plausible implication is that they nevertheless extend the same underlying intuition: complexity is often determined by the structure of mediation itself—recursive interaction in IntComplex, and causally organized dialogue in interactive-behavior complexity—rather than by flat counts alone.