Recursive Concept Evolution (RCE)

• Recursive Concept Evolution (RCE) is a family of frameworks that recursively forms, edits, and re-encapsulates concepts using self-reference, memory integration, and dynamic selection.
• It is applied in both self-editing computation and large language models to adapt internal representations via low-rank concept subspaces and hierarchical organization.
• The approach integrates methods like Darwinian selection, MDL-based gating, and recursive encapsulation to improve meta-learning, robustness, and adaptive reasoning.

Searching arXiv for the cited RCE-related papers and closely related work to ground the article. arXiv search query: "Recursive Concept Evolution" Recursive Concept Evolution (RCE) denotes a family of frameworks in which concept formation, adaptation, and higher-order reorganization proceed through recursive transformation of an internal representational or programmatic substrate. Across the literature, the term spans at least three distinct but partially overlapping formulations: a self-editing computational theory rooted in program-as-input self-reference and Darwinian selection (Arvanitakis, 2020), an inference-time representation-editing framework for LLMs that introduces dynamically generated low-rank concept subspaces (Chaudhry, 17 Feb 2026), and a broader hierarchical interpretation in which concept evolution is coupled to recursive encapsulation and dominant-function selection across layers of organization (Li et al., 6 Sep 2025). A related operational realization appears in evolving recursive definitions, where recursive clauses become persistent computational knowledge through parallel universal quantification and automatic memoization (Kwon, 2022). Taken together, these works treat concepts not as static symbols but as recursively constructed, selected, stored, merged, and re-instantiated entities whose evolution can occur within code, within hidden-state geometry, or across hierarchical system levels.

1. Origins in self-reference and self-editing computation

The earliest explicit formalization associated with RCE in the supplied corpus is the self-referential learning theory developed in "Recursion, Evolution and Conscious Self" (Arvanitakis, 2020). Its basic object is a code $c$, understood as a structured string over a finite alphabet, possibly containing executable and data parts, where an executable program $c$ codes for an algorithm $\mathrm{alg}(c)$. The central operation is self-editing: a program can take its own program as input and compute descendants of itself.

The paper formalizes a self-editing computation $C_1, C_2, \ldots$ by

$$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$

for every $k=1,2,\ldots$, together with

$$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$

Subcode and state notation are integral to the construction: $c=c[b]$ means $b$ is a subcode of $c$; $c$0 denotes the current state with $c$1 activated; $c$2 denotes removing $c$3 or an empty subcode. Addresses index subparts, enabling operations on structured subcodes (Arvanitakis, 2020).

The foundational statement is the Basic Self-Editing Principle:

$c$4

For any algorithm $c$5, there exists a code $c$6 for $c$7 such that, for any code $c$8, activating $c$9 inside $\mathrm{alg}(c)$0 causes the self-editing step to compute exactly the transformation $\mathrm{alg}(c)$1 on the program itself (Arvanitakis, 2020). In the paper’s synthesis, this is identified as the constructive backbone of RCE. It operationalizes self-reference as program-as-input and functions as a constructive fixed-point schema in the flavor of Kleene’s second recursion theorem, though the text explicitly notes that it does so without relying on contradiction.

A second key extension is the proliferating principle:

$\mathrm{alg}(c)$2

If $\mathrm{alg}(c)$3 are algorithms, there is a code $\mathrm{alg}(c)$4 such that a self-editing program can produce multiple descendants, yielding tree-structured evolutionary computations (Arvanitakis, 2020). This turns variation into an algorithmic offspring-generation mechanism and establishes a direct formal bridge between recursive self-reference and Darwinian branching.

The same framework includes a Programming Lemma for embedding arbitrary structured programs inside self-editing codes and a Memory Lemma for complete-memory self-editing, where descendants can be computed from the embedded history

$\mathrm{alg}(c)$5

with

$\mathrm{alg}(c)$6

This matters because RCE, in this formulation, is not only self-modification of the current state; it is recursive reorganization conditioned on the history of prior states, thereby making pattern extraction over one’s own evolution an explicit computational object (Arvanitakis, 2020).

2. Concepts as subcodes, modules, and persistent computational objects

In the self-editing formulation, concepts correspond to structured subcodes and modules. They may appear as stored instructions, differentiating codes, learned tests, or specialized substructures that capture regularities in the agent’s history or environment (Arvanitakis, 2020). The paper states that concept-like units arise as stored instructions (codes $\mathrm{alg}(c)$7), differentiating codes, modules, and specialized subcodes that can be reused, composed, and invoked.

A basic storage operation is given by the algorithm $\mathrm{alg}(c)$8, which appends a code $\mathrm{alg}(c)$9 into a new available address. The text summarizes this as storing $C_1, C_2, \ldots$0 in an available address. Differentiating codes implement concept-driven modification. Three forms are distinguished (Arvanitakis, 2020):

• Temporary differentiating code: use $C_1, C_2, \ldots$1 as a temporary differentiating code, operationally

$C_1, C_2, \ldots$2

• Permanent differentiating code: use $C_1, C_2, \ldots$3 as a permanent differentiating code, with repeated application

$C_1, C_2, \ldots$4

• $C_1, C_2, \ldots$5-differentiating decisions: apply $C_1, C_2, \ldots$6 to the content of address $C_1, C_2, \ldots$7:

$C_1, C_2, \ldots$8

This representation of concepts is operational rather than semantic. A concept is whatever structured subcode stores a reusable regularity and can be activated, specialized, copied, or composed. The supplied synthesis explicitly characterizes concepts as modules that often embody relations such as “add(1) to environmental output,” “copy subpart,” or “predict output from input via $C_1, C_2, \ldots$9” (Arvanitakis, 2020).

A related but computationally narrower notion appears in evolving recursive definitions (Kwon, 2022). There, recursively defined functions behave as evolving conceptual objects. The paper distinguishes blindly-quantified (BQ) definitions,

$$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$0

from parallel universally quantified (PUQ) definitions,

$$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$1

Under BQ, the instance created during evaluation is discarded. Under PUQ, the instance is retained, so the definition evolves by permanently adding computed cases. The decisive operational rule is

$$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$2

which appends the solved instance to the front of the program (Kwon, 2022). In this setting, a concept is effectively a recursively defined function whose extension grows through computation. This makes knowledge accumulation part of the semantics rather than an implementation-level memoization trick.

These two lines of work converge on a common idea: concepts are not merely represented; they are retained as actionable internal structures whose future computational role depends on their prior activation history.

3. Recursive evolution, diagonalization, and meta-learning

The most distinctive mechanism in the self-editing account is diagonalization, described as algorithmic meta-learning and selection over patterns (Arvanitakis, 2020). Given a successful or surviving sequence $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$3, the agent searches for a simple code $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$4 that fits observed transitions and then installs $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$5 as a differentiating code to perpetuate the pattern. The fit relation is defined so that $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$6 fits $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$7 when $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$8, with partial outputs allowed.

The search is automated by a decision system $$C_{k+1} = \mathrm{step}\text{-}\mathrm{alg}(c_k)(C_k)$$9, where $k=1,2,\ldots$0 is a searcher proposing codes $k=1,2,\ldots$1 with priorities encoding simplicity, and $k=1,2,\ldots$2 is a tester evaluating fit via an algorithmic test $k=1,2,\ldots$3 and choosing simpler $k=1,2,\ldots$4 with $k=1,2,\ldots$5 (Arvanitakis, 2020). The sequential diagonalization principle is stated as

$k=1,2,\ldots$6

The supplied synthesis explains this operationally as follows: when an agent’s diagonalization code $k=1,2,\ldots$7 is activated in $k=1,2,\ldots$8, the self-editing step equals applying $k=1,2,\ldots$9 to the full memory-embedded history, enabling perpetuation of patterns over its own evolution $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$0 and over behavior $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$1 (Arvanitakis, 2020).

This is the point at which RCE becomes explicitly recursive in the strong sense. The system does not merely infer concepts from data; diagonalization itself is subject to evolution. The paper states that diagonalization applies to its own history $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$2, so the machinery that proposes, tests, prioritizes, and installs concepts is itself a target of further concept formation (Arvanitakis, 2020). That is the paper’s meta-learning core.

Additional mechanisms refine this loop. Statistical diagonalization fits a simple instruction $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$3 to a fraction of observed transitions and uses the corresponding code $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$4 with matching relative frequency. Parallel diagonalization removes order dependence and supports concept abstraction by fitting sets of transitions across multiple instances, such as common features among different dogs, yielding generalized concepts like “dog” or “number 2” (Arvanitakis, 2020). Specialization arises when disagreement rates between accepted $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$5-differentiating codes and initial search priorities trigger $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$6-specializing instructions, producing hierarchical decision units and diagonalization over diagonalization submodules.

Resource constraints are incorporated rather than ignored. Because $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$7 may not halt, the paper introduces experience-based timeouts:

For every proposed code $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$8 and every code $$\mathrm{self}\text{-}\mathrm{ed}(c_k)= \mathrm{step}\text{-}\mathrm{alg}(c_k)(c_k)=C_{k+1}.$$9 in memory, wait at most $c=c[b]$0 steps to calculate $c=c[b]$1.

This is presented as a practical response to undecidability, tied to surviving or successful sequences and to the evolution of bounded evaluation policies (Arvanitakis, 2020). Homeostasis and preservation of variation complete the picture: the framework conservatively keeps locally optimal parameter values constant, rolls back increases that become harmful, and maintains proliferating descendants to hedge against uncertain future environments (Arvanitakis, 2020).

A comparable but more constrained recursion appears in RHN, where the recursive update is

$c=c[b]$2

The paper interprets RCE on the functional plane as recursive aggregation to candidate concept sets, competitive selection of a unique dominant concept $c=c[b]$3, and encapsulation into a new concept-node:

$c=c[b]$4

where $c=c[b]$5 is the first time such that $c=c[b]$6 (Li et al., 6 Sep 2025). This is a different formalism, but it preserves the same recursive theme: concepts are aggregated, selected, sealed, and recursively reintroduced as higher-level units.

4. Representation-level RCE in LLMs

A later and much more implementation-oriented use of the term appears in "Recursive Concept Evolution for Compositional Reasoning in LLMs" (Chaudhry, 17 Feb 2026). Here, RCE refers to an inference-time framework that enables pretrained LLMs to modify their internal representation geometry during inference rather than merely expanding token-level search.

The paper starts from a fixed-geometry diagnosis. Let $c=c[b]$7 be a pretrained autoregressive LLM with parameters $c=c[b]$8 and hidden dimension $c=c[b]$9. Hidden states evolve by

$b$0

The hidden-state covariance at layer $b$1 is written as

$b$2

with an effective representational rank defined from its singular values relative to a threshold $b$3 (Chaudhry, 17 Feb 2026). The paper’s bottleneck claim is that if a task requires a latent structure $b$4 largely orthogonal to the column space of $b$5, downstream layers cannot represent that structure regardless of decoding strategy.

RCE addresses this by augmenting a frozen base model at inference with dynamically generated low-rank concept subspaces. A concept $b$6 consists of a basis matrix $b$7 with orthonormal columns, a gating function $b$8, and a projection operator $b$9, with $c$0 and $c$1 in the experiments (Chaudhry, 17 Feb 2026). Injection at a designated decoder layer $c$2 uses

$c$3

This modifies hidden activations while keeping the base model weights $c$4 frozen (Chaudhry, 17 Feb 2026).

The RCE loop in this paper has four mechanisms:

1. Detect representational inadequacy through the failure score

$c$5

where

$c$6

2. Spawn candidate concept subspaces through a three-layer MLP generator $c$7 conditioned on the pooled hidden state

$c$8

producing

$c$9

followed by Gaussian perturbation with $c$00 and QR orthogonalization.

3. Accept concepts only if they satisfy the MDL criterion

$c$01

and

$c$02

4. Merge synergistic concepts according to

$c$03

accepting a merge only if

$c$04

where $c$05 is formed by concatenating $c$06, applying rank-$c$07 truncation via SVD, and then QR orthogonalization (Chaudhry, 17 Feb 2026).

Regularization includes inter-concept orthogonality, intra-concept orthonormality, and gate entropy penalties. The total loss is

$c$08

with an optional KL-constrained update

$c$09

implemented via a KL penalty and dual gradient descent on $c$10 (Chaudhry, 17 Feb 2026).

The paper also states a representation-capacity proposition: with any concept $c$11 whose basis activates on a set of inputs of positive measure, the effective rank of the hidden-state covariance satisfies $c$12, with strict inequality if $c$13 has nontrivial projection onto the null space of $c$14 (Chaudhry, 17 Feb 2026). A PAC-Bayesian generalization bound is given in terms of the total MDL cost $c$15:

$c$16

This version of RCE is therefore materially different from the self-editing theory. It does not treat code as input to itself. Instead, it treats representational geometry as the evolving object and concepts as low-rank subspaces that are spawned, routed, merged, and crystallized during controlled training or inference (Chaudhry, 17 Feb 2026).

5. Empirical behavior, benchmarks, and implementation profiles

The LLM-oriented paper provides the most explicit empirical evaluation among the supplied sources (Chaudhry, 17 Feb 2026). Integrated into Mistral-7B-v0.1 with a single forward hook at decoder layer $c$17 in a 32-layer decoder of hidden dimension $c$18, and with the base model frozen, RCE is evaluated on ARC-AGI-2, MATH, BBH, GPQA, and HLE using accuracy as the metric.

The main reported results on Mistral-7B are as follows (Chaudhry, 17 Feb 2026):

Method	ARC-AGI-2	MATH	BBH
Base	12.4	28.6	51.3
DisCO	19.7	41.3	64.8
RCE	28.0	47.4	70.5

Method	GPQA	HLE
Base	24.1	8.2
DisCO	34.2	13.8
RCE	41.4	18.7

The full comparison in the paper also includes CoT, self-consistency with $c$19, ToT, and GRPO. The text summarizes the gains as 12–18 points on ARC-AGI-2, 8–14 point improvements on GPQA and BBH, and consistent reductions in depth-induced error on MATH and HLE (Chaudhry, 17 Feb 2026).

Out-of-distribution robustness is reported for ARC-AGI-2 under color permutation, spatial rotation, and distractor injection. RCE retains 94.3%, 91.7%, and 95.8% of standard accuracy, compared with CoT at 71.2/68.4/74.1 and DisCO at 78.5/73.9/80.2 (Chaudhry, 17 Feb 2026). Compute measurements on MATH show:

Method	FLOPs	Accuracy
Base	1.0×	28.6%
CoT	3.2×	34.2%
SC (n=16)	16.0×	37.1%
ToT	24.5×	36.8%
RCE	1.04×	47.4%

Ablations identify the MDL component as the largest contributor among the removed modules. On ARC-AGI-2/MATH, Full RCE scores 28.0/47.4, while removing MDL yields 14.6/31.2; removing invariance augmentation yields 18.3/39.8; removing KL yields 21.5/35.6; removing merge yields 23.1/42.7; removing orthogonality yields 20.4/38.1; removing gate entropy yields 25.2/44.3 (Chaudhry, 17 Feb 2026).

Hyperparameter sensitivity on ARC-AGI-2 is also reported. Rank $c$20 is the default and gives 28.0, compared with 22.1 at $c$21, 25.3 at $c$22, and 27.4 at $c$23. Top-$c$24 gives 28.0, while $c$25 give 24.6, 27.2, and 25.8 respectively. The default spawn threshold is $c$26, the default MDL weight is $c$27, and the default orthogonality weight is $c$28 (Chaudhry, 17 Feb 2026).

Implementation details are unusually explicit. The system uses PyTorch 2.6 and Hugging Face Transformers 4.48; the primary model is Mistral-7B-v0.1 in bfloat16; training occurs on a single NVIDIA RTX 5090 (24GB), sequence length 512, batch size 1, at approximately 1,200 steps per hour. Each concept adds approximately $c$29 parameters, about 65,536 parameters; a library of 128 concepts occupies about 33MB, and concept library plus gate plus generator checkpoints occupy about 55MB (Chaudhry, 17 Feb 2026).

By contrast, the self-editing paper (Arvanitakis, 2020) offers conceptual validation through mental experiments rather than benchmarked performance. Its examples include fill-the-dots sequences such as $c$30 and $c$31, where diagonalization identifies “add(1)” or evolves a higher-level “add(k)” module across sub-experiments. The paper explicitly states that no formal convergence analysis is provided and that stabilization is achieved conceptually through homeostasis, conservative strategies, and long-term memory fits (Arvanitakis, 2020). The evolving-recursion paper (Kwon, 2022) likewise provides operational semantics and examples, especially Fibonacci, but no formal soundness, completeness, or termination theorems.

6. Biological, hierarchical, and conceptual interpretations

The self-editing account explicitly seeks alignment with biology and neuroscience (Arvanitakis, 2020). It states that diagonalization agrees with Hebbian theory: “Ignoring the terms surviving and successful, diagonalization is in agreement with Hebbian theory [37].” Repeated co-activation is thus interpreted as producing permanent decisions that strengthen links, paralleling synaptic reinforcement. Concepts are associated with assemblies of neurons and modular subcodes, and the framework is presented as compatible with modularity arguments in biology and neuroscience.

The same paper also draws an analogy to predictive processing. In the model, diagonalization searches for a code $c$32 such that for each past input $c$33 and output $c$34, $c$35, thereby enabling prediction of suggested outputs for new inputs (Arvanitakis, 2020). Because full diagonalization is memory-intensive, evolved test codes $c$36 can replace more expensive search on learned substructures, yielding a hierarchical internal model. The supplied synthesis states that this is “akin to predictive processing,” which should be treated as an interpretive alignment rather than a literal identity.

Additional biological interpretations concern time perception, emotion, sex, and variability. Shortened subjective time with age is explained as fewer self-evolution steps and improved environmental understanding requiring fewer associations. Fear is described as compressing cycles by prioritizing rapid reconfiguration on shorter intervals. Sexual reproduction is interpreted as a mixture of sequential and parallel diagonalization across two surviving sequences, with opposite types presented as searcher/tester analogs. Preservation of variation is linked to uncertain futures and polymorphism (Arvanitakis, 2020). These are presented in that paper as explanatory correspondences rather than empirical experimental results.

RHN offers a broader systems-theoretic interpretation (Li et al., 6 Sep 2025). It defines Recursive Concept Evolution on the functional plane through recursive aggregation to candidate functional-concept sets, competitive selection to a unique dominant concept, and encapsulation into a new concept-node. This occurs within a larger law-governed process where functional levels progress monotonically through structure-dominated, regulation-dominated, and intelligence-dominated stages. The paper’s law of functional evolution states monotonicity, stepwise progression, irreversibility, and the uniquely ordered stage sequence $c$37 under assumptions about hierarchical recursion, unique dominant-function selection, and information-compressing fusion and sealing (Li et al., 6 Sep 2025).

Within that framework, functional capacity is tracked by

$c$38

with transitions when $c$39 and intelligence-dominated entry when $c$40 (Li et al., 6 Sep 2025). Empirically, the paper reports strictly monotonic trajectories across life, information, society, and cosmos; pairwise cosine similarities including life–information 0.94 and information–society 0.93; resonance at $c$41 and $c$42; and present positions of life $c$43, information $c$44, society $c$45, cosmos $c$46 (Li et al., 6 Sep 2025). This is not the same framework as self-editing RCE or LLM RCE, but it supplies a hierarchical reinterpretation in which concept evolution is one instance of recursive encapsulation across scales.

7. Comparisons, misconceptions, and open problems

A recurrent misconception is that RCE refers to a single settled formalism. The supplied literature does not support that view. Instead, at least four distinct uses exist.

First, in self-editing computation, RCE is recursive concept formation through program-as-input self-reference, proliferation, memory, diagonalization, and Darwinian selection (Arvanitakis, 2020). Second, in LLMs, RCE is representation-level adaptation through low-rank concept subspaces, MDL selection, sparse routing, and synergy-driven merging in a frozen base model (Chaudhry, 17 Feb 2026). Third, in RHN, RCE is the conceptual counterpart of node $c$47 module $c$48 system $c$49 new node encapsulation governed by thresholds, dominant-function selection, and stage progression (Li et al., 6 Sep 2025). Fourth, in evolving recursive definitions, RCE is naturally realized when recursive clauses persist through PUQ semantics and thereby accumulate solved instances (Kwon, 2022).

A second misconception is that RCE is merely another name for chain-of-thought or token-level search. The LLM paper explicitly argues otherwise: CoT, self-consistency, ToT, GRPO, and DisCO expand or refine output trajectories while leaving hidden representation geometry fixed, whereas RCE modifies the representation itself by injecting learned low-rank concept subspaces (Chaudhry, 17 Feb 2026). The same paper also distinguishes RCE from fixed offline representation editing such as LoRA, adapters, activation steering, and CAVs by emphasizing online spawning, sparse routing, MDL gating, and hierarchical merging.

A third misconception is that the self-editing theory provides established convergence guarantees. The source explicitly states that no formal convergence analysis is given (Arvanitakis, 2020). Likewise, the evolving-recursion paper provides operational semantics but no soundness, completeness, termination, or complexity theorems beyond the practical implication that dynamic-programming-like efficiencies arise when overlapping subproblems are memoized (Kwon, 2022).

Several open problems are named directly in the sources. For self-editing RCE, they include formal guarantees on meta-learning convergence and stability, efficient searcher design and priority update rules, scalable memory management, formal abstraction formation via parallel diagonalization, and integration with modern ML while preserving self-editing semantics (Arvanitakis, 2020). For LLM RCE, the paper notes failure modes on extremely long proofs where single-layer injection limits depth of restructuring, on tasks needing explicit external memory beyond attention, and under adversarial inputs aligned to concept bases; it recommends possible multi-layer injection, memory-augmented transformers, and adversarial training of the concept library (Chaudhry, 17 Feb 2026). For evolving recursive definitions, open directions include formalization of the proposed object-oriented language $c$50, integration with CoLweb agents, study of termination and complexity under different quantifier combinations, and the interaction of evolving recursion with imperative features and concurrency (Kwon, 2022). RHN, for its part, identifies assumptions such as hierarchical recursion, node capacity, and single dominant function per layer, and presents falsifiable predictions concerning monotonicity, encapsulation necessity, stage order, and future transitions in information systems and society (Li et al., 6 Sep 2025).

A plausible implication is that “Recursive Concept Evolution” should presently be read as a research program rather than a single theory. Across its variants, however, one organizing motif remains stable: concepts are not fixed primitives but recursively transformable entities whose persistence, selection, and re-encapsulation alter the future space of possible computations or inferences. In the self-editing formulation this transformation occurs in code and memory; in LLMs it occurs in latent geometry; in RHN it occurs across hierarchical functional layers; and in evolving recursion it occurs in the program state itself through persistent instance creation.