Authors: [LENOVO] Date: 2026-08-06 Status: Draft v1.0 — targeted feedback welcome Repository: [to be created]
When a causal agent models its own model-generation mechanism, it crosses a boundary that Pearl's causal hierarchy does not address. We define a Reflective Structural Causal Model (R-SCM) by introducing a G-node—a variable whose value encodes the SCM's own structural description. We then define the reflection rank ρ_T(A), a proof-theoretic parameter measuring how many layers of logical reflection are needed to internally certify an agent's future causal correctness. We construct a full spectrum of agents (ρ = 0, 1, 2, ..., ω, ∞) and prove three core lemmas: composable agents are certifiable (ρ = 0), self-modifying agents require unbounded reflection (ρ = ∞), and the intermediate ranks form a strict hierarchy protected by Löb's theorem. Finally, we show that ρ maps directly to a thermodynamic cost via Bennett's principle of logical irreversibility—closing a three-way correspondence between computability theory (Rice, Gödel, Löb), causal inference (Pearl, CHT), and thermodynamics (Landauer, Bennett). A translation table is provided.
Three research communities have independently developed formal tools for reasoning about limits:
- Computability theory: Gödel's incompleteness theorems, Rice's theorem, Löb's theorem, and Feferman's reflection progressions describe what formal systems can and cannot prove about themselves.
- Causal inference: Pearl's structural causal models (SCM) and the Causal Hierarchy Theorem (CHT) establish strict containment L1 ⊂ L2 ⊂ L3 between observational, interventional, and counterfactual reasoning.
- Thermodynamics of computation: Landauer's principle and Bennett's refinement connect logical irreversibility to physical entropy, establishing that information erasure has a fundamental energy cost.
These communities rarely read each other's work. Yet at their intersection lies a single deep structure: what happens when a system must reason about its own reasoning mechanism?
This paper identifies that structure. We show that a self-modeling causal agent encounters a reflection rank—a proof-theoretic parameter ρ that simultaneously measures:
- The number of reflection extensions needed to internally certify the agent's future causal correctness (computability)
- Whether the agent's self-model can be absorbed by Pearl's L3 counterfactual layer (causality)
- The thermodynamic cost of the agent's self-modification operations (physics)
The result is not merely an analogy. Each row of the correspondence is a reduction or isomorphism.
A Structural Causal Model M = ⟨U, V, F, P(U)⟩ consists of:
- U: exogenous variables (noise)
- V = {V₁, ..., Vₙ}: endogenous variables
- F = {f₁, ..., fₙ}: for each Vᵢ, vᵢ = fᵢ(paᵢ, uᵢ) where paᵢ ⊆ V
- P(U): probability distribution over U
Pearl's Causal Hierarchy (CHT, Bareinboim et al. 2022) establishes:
L1 (observational) ⊂ L2 (interventional) ⊂ L3 (counterfactual)
with strict containment at each level.
Definition 1 (R-SCM). A Reflective SCM M_R = ⟨U, V, F, P(U)⟩ is a standard SCM with a distinguished variable G ∈ V, called the G-node, satisfying:
- dom(G) = Σ, where Σ is a set of SCM structural descriptions.
- G = f_G(pa(G), u_G), where pa(G) ⊆ V.
- For all X ∈ V \ {G}, X = f_X(pa(X), u_X), where pa(X) ⊆ V (may include G).
The G-node represents the agent's model generator within the causal model. When G ∈ pa(G), the SCM is reflectively closed: the update rule for G references G's own current value—a causal fixed-point equation G = f_G(G, pa_other, u_G).
Theorem 1 (G-Node Absorption). Let M_R be an R-SCM.
Case 1 (no reflection): If G ∉ pa(G), then all causal queries about G are answerable within L3. The G-node is absorbed by the CHT hierarchy.
Case 2 (reflection): If G ∈ pa(G), there exist queries of the form "what would the SCM structure be if G had taken a different value that itself depends on G?" (denoted Q4) that are not answerable within L3.
Proof sketch. Case 1: G ∉ pa(G) ⇒ f_G does not depend on G. The structural equation is a standard recursive definition; counterfactual reasoning about f_G is within L3's scope. Case 2: G ∈ pa(G) ⇒ queries about G's counterfactual values require solving the fixed-point equation G' = f_G(G', ...). L3 provides no general mechanism for such fixed points, and their existence/uniqueness is not guaranteed without additional structure. ∎
Relationship to CHT. CHT establishes L1 ⊂ L2 ⊂ L3. R-SCM extends this map: the G-node defines a new region adjacent to L3. When non-reflective, the G-node collapses into L3. When reflective, it sits outside L3, parameterized by the reflection rank ρ defined below.
Definition 2 (CCL Agent). A Causal-Computational-Logical agent is a tuple A = ⟨T, L, M, G, O⟩ where:
- T is a formal reasoning system (≥ PA, with Gödel coding and induction)
- L is a causal language defining expressible queries Q_A
- M is the current SCM
- G: M × Evidence → M is the model generator
- O: World → Evidence is the observation model
Definition 3 (Future Correctness). For agent A with initial model M₀:
FC_A(G, M₀) := ∀t ≥ 0 . Correct_A(G^t(M₀))
where Correct_A(M) := ∀q ∈ Q_A(L) . Answer_M(q) = Answer_World(q).
Definition 4 (Reflection Progression).
T^0 := T
T^{α+1} := T^α + Rfn(T^α) where Rfn(T) := ∀φ . (Pr_T(⌜φ⌝) → φ)
T^λ := ∪_{β<λ} T^β (λ a limit ordinal)
This is the standard Feferman (1962) construction. T^(1) proves Con(T); T^(2) proves Con(T^(1)); and so on.
Definition 5 (Reflection Rank).
ρ_T(A) := min{ α : T^α ⊢ FC_A(G, M₀) }
If no such α exists, ρ_T(A) = ∞.
This is the minimal number of reflection extensions needed to internally certify the agent's future causal correctness.
Key properties:
- ρ_T(A) = 0 ⇔ T proves FC directly (no reflection needed)
- ρ_T(A) = 1 ⇔ T + Rfn(T) proves FC, but T alone does not
- ρ_T(A) = n ⇔ exactly n layers of reflection are needed
- ρ_T(A) = ∞ ⇔ no finite or countable tower suffices
Construction. A Compositional Causal Agent (CCA) uses a generator of the form:
G_comp(M, e) = M ⊗ {a : V(a, e) = Accept}
where ⊗ is conservative extension (adding causal arcs without modifying existing ones) and V is a do-calculus-based arc verifier whose correctness is axiomatized within T.
Theorem 2. ρ_T(A_CCA) = 0.
Proof. By induction on t:
- Base: M₀ is empty ⇒ Correct(M₀) trivially.
- Step: M_{t+1} = M_t ⊗ {a_i}. Each a_i is verified by V ⇒ correct (by V's axiomatized correctness). ⊗ is conservative ⇒ existing arcs preserved. ∴ Correct(M_{t+1}).
- Induction is ω-induction, available in PA (|PA| = ε₀ >> ω). No reflection principle is invoked. ∴ T ⊢ FC → ρ = 0. ∎
Construction. ToyCCA uses the PC algorithm (constrained to only add arcs) for causal discovery, with Faithfulness as a global assumption.
Theorem 3. ρ_T(A_ToyCCA) = 0.
Proof. The proof structure is isomorphic to Lemma 1. The PC algorithm's collider-based orientation rules are encoded in V; the induction step is identical. Faithfulness is a premise, not a reflection principle. ∎
Key insight. ToyCCA's behavior involves infinite iteration (ω time steps), yet its certification requires zero reflection. Infinite behavior ≠ high reflection rank. The rank measures proof-theoretic depth, not temporal depth.
Construction. A_v05 is a CCL agent satisfying:
- G is Turing-complete and self-modifying
- Reflective closure: ĝ ⊆ M (the model contains a representation of G equivalent to G itself)
- Meta-queries: Q_A includes q_con ≡ "does T's causal reasoning always produce correct results?"
Theorem 4. ρ_T(A_v05) = ∞.
Proof. For any given ordinal α, we show T^α ⊬ FC.
-
Since G is Turing-complete and reflectively closed, A_v05 can internally simulate the construction of the Feferman tower. Given any n < ω, after ≤ n self-modifications, A_v05's effective reasoning strength reaches T^(n).
-
The meta-query q_con, when evaluated at this state, becomes equivalent to Con(T^(n)). Since FC requires Correct(M), which requires the meta-query to return "true," we have FC → Con(T^(n)) for the relevant n.
-
For finite n: T^(n) is recursively axiomatized. By Gödel II, T^(n) ⊬ Con(T^(n)). Therefore T^(n) ⊬ FC. Since this holds for all finite n, ρ > n for all n.
-
For limit λ: T^λ = ∪_{β<λ} T^β. Any proof in T^λ uses finitely many axioms, hence appears in some T^β for β < λ. Since T^β ⊬ FC for all β < λ, we have T^λ ⊬ FC.
-
Since no α satisfies T^α ⊢ FC, ρ_T(A_v05) = ∞. ∎
In R-SCM terms: the G-node satisfies G-node ⊄ L3^α for all α—infinite departure from the causal hierarchy.
The reflection rank forms a strict hierarchy:
| ρ | Agent Class | R-SCM Status | Certification |
|---|---|---|---|
| 0 | Compositional (CCA, ToyCCA) | G-node ⊆ L3 | T-internal induction |
| 1 | Consistency-aware (meta-queries, no self-modification) | G-node ⊆ L3^1, ⊄ L3 | T + Rfn(T) |
| n | n-layer self-modifying | G-node ⊆ L3^n, ⊄ L3^{n-1} | T^(n) |
| ω | Arbitrary finite self-modification | G-node ⊆ L3^ω, ⊄ L3^n (∀n<ω) | T^(ω) (ω-rule) |
| ∞ | Unbounded self-modification (v0.5G) | G-node ⊄ L3^α (∀α) | Divergent |
Theorem 5 (Löb Hierarchy Protection). The reflection rank is strictly monotonic: if ρ_T(A) = n+1, then ρ_T(A) ≠ n. That is, T^(n+1) ⊋ T^(n) as a strict extension—the hierarchy cannot be collapsed.
Proof. If T^(n) ⊢ Rfn(T^(n)), then by Löb's theorem, T^(n) would be inconsistent. Therefore Rfn(T^(n)) ∉ T^(n), and T^(n+1) is a strict extension. ∎
Bennett (1982) established: any logically irreversible operation—an operation whose output does not uniquely determine its input—must, when physically implemented, dissipate energy as heat. This is the logical irreversibility → physical irreversibility principle. Unlike the original Landauer bound (kT ln 2), this directional principle is uncontroversial.
In R-SCM, the G-node's update function is f_G. Consider an agent attempting to evaluate FC(G, M) as part of f_G's computation.
Theorem 6 (Non-Injectivity of f_G under Reflection). When G ∈ pa(G) and Q_A includes FC-determination queries, f_G is not injective on its domain.
Proof. FC is undecidable (Rice's theorem applied to the semantic property Correct). Any finite computation D_fin approximating the FC decision must map some instance pair (G₁, M₁) with FC=true and (G₂, M₂) with FC=false to the same output—otherwise FC would be decidable. Since f_G incorporates D_fin, f_G(G₁, M₁, ...) = f_G(G₂, M₂, ...) while (G₁, M₁) ≠ (G₂, M₂). Therefore f_G is not injective. ∎
Define the collision rate κ(f_G) = 1 - |f_G(D)|/|D|. When f_G is injective (κ = 0), no information is erased and Bennett cost is zero. As κ increases, more input states are merged, more information is erased, and the thermodynamic cost grows.
Theorem 7 (ρ–Entropy Monotonicity). The Bennett entropy cost S_B(f_G) is a monotonic function of ρ_T(A).
Proof. ρ₁ < ρ₂ ⇒ G-node operates at a higher reflection depth ⇒ f_G must merge more indistinguishable instances (by Theorem 6 applied at each reflection layer) ⇒ κ(f_G) increases ⇒ S_B ∝ κ · log₂|dom(G)| increases. The composition of monotonic functions is monotonic. ∎
| ρ | Computational | Causal (R-SCM) | Thermodynamic |
|---|---|---|---|
| 0 | T ⊢ FC | G-node ⊆ L3 | Zero cost (reversible) |
| 1 | T^(1) ⊢ FC | G-node ⊆ L3^1 | O(1) erasure |
| n | T^(n) ⊢ FC | G-node ⊆ L3^n | O(n) erasure |
| ω | T^(ω) ⊢ FC | G-node ⊆ L3^ω | Unbounded (compressible) |
| ∞ | Divergent | G-node ⊄ L3^α ∀α | Divergent |
The following table maps the core concepts across the three frameworks. Each row is a structural correspondence—not a metaphor.
| # | Concept | Computability | Causality (R-SCM) | Thermodynamics | Strength |
|---|---|---|---|---|---|
| 1 | Self-representation | Gödel code ⌜T⌝ ∈ T | G-node ∈ V, G ∈ pa(G) | Demon self-measurement loop | ≡ |
| 2 | Model generator | Turing-complete G | G-node: G = f_G(pa(G), u_G) | State transition Γ | → |
| 3 | Fundamental limit | Rice undecidability of FC | G-node ⊄ L3 (Q4 unanswerable) | f_G non-injective → Bennett cost | → / ↔ |
| 4 | Bypass condition | ρ = 0 (compositional G) | G ∉ pa(G) (G-node ⊆ L3) | Reversible computation, no erasure | ≡ |
| 5 | Depth hierarchy | ρ = 0,1,2,...,ω,∞ | G-node absorption depth | Entropy cost g(ρ) | → |
| 6 | Hierarchy protection | Löb: □(□P→P)→□P | CHT: L1⊂L2⊂L3 | 2nd Law: entropy non-decreasing | ≈ |
| 7 | Self-modification event | G rewrites own code | G-node value update (old value overwritten) | Behavioral info erased → entropy | ≡ |
| 8 | Bounded cost | Restricted depth ≤ k | k-layer reflection → absorbed | Finite total entropy budget | → |
Strength key: ≡ isomorphism, → reduction, ↔ bidirectional reduction, ≈ structural analogy (common diagonalization root).
Causal Hierarchy (CHT). Bareinboim et al. (2022) proved L1 ⊂ L2 ⊂ L3. R-SCM extends this map to include the G-node region without challenging the hierarchy for non-reflective variables.
Embedded Agency. Demski & Garrabrant (2019) surveyed formal obstacles for agents embedded in their environments. The reflection rank ρ provides a quantitative parameter for one such obstacle: self-model certification.
Reflective Oracles. Fallenstein et al. (2015) established the existence of probabilistic fixed points for self-referential games. RCCL addresses a distinct question: not whether fixed points exist, but at what proof-theoretic cost they can be internally certified.
Logical Induction. Garrabrant et al. (2016) provided a computable algorithm for assigning probabilities to logical statements. The ρ hierarchy suggests that different logical induction strategies may inhabit different reflection ranks.
Thermodynamics of Computation. Landauer (1961) identified the energy cost of bit erasure. Bennett (1982) generalized to logical irreversibility. The present work identifies a new source of logical irreversibility: undecidable self-certification in reflective agents.
- Not a claim that AI cannot understand itself. CCA/ToyCCA agents (ρ = 0) can internally certify their causal correctness.
- Not a new layer in Pearl's hierarchy. The G-node extends the map adjacent to L3 without adding "L4."
- Not a defense of Landauer's original kT ln 2 formula. The thermodynamic argument uses Bennett's uncontroversial directional principle.
- A proof that self-modeling causal agents inhabit a reflection rank spectrum, with structural conditions determining their position.
- A demonstration that three fundamental limits—Rice undecidability, CHT non-absorption, and Bennett irreversibility—are three expressions of the same structure.
- A translation table enabling researchers in each community to read the results of the other two.
If an AI system's model updates are not compositional (i.e., cannot be expressed as M ⊗ Δ with independently verifiable Δ), its reflection rank is strictly positive—meaning it cannot internally certify its own future correctness. For such systems, external certification mechanisms, bounded reflection budgets, or compositional architectural constraints become necessary.
-
Spectrum Theorem. For any recursive ordinal α, does there exist an agent A_α with ρ_T(A_α) = α? (Conjecture: yes, by nesting self-modification layers to increasing ordinal depth.)
-
Self-Estimation. Can an agent at rank n determine its own rank? We suspect a "self-awareness blind spot" analogous to Gödel's second incompleteness—agents cannot precisely determine their own ρ from within.
-
Multi-Agent Reflection. When multiple agents' G-nodes reference each other, what is the joint reflection rank?
-
Quantitative ρ–Entropy Mapping. The exact form of S_B(ρ) remains conjectural. Information-theoretic bounds on collision rates for undecidable problems may provide tighter estimates.
-
CHT Extensions. Can the G-node be integrated into do-calculus, providing a "reflective do-calculus" that handles interventions on self-referential variables?
Thanks to Scott Aaronson for the observation that Rice's theorem blocks general certification but not specific cases—this directly motivated the CCA construction and the reflection spectrum.
- Bareinboim, E., Correa, J. D., Ibeling, D., & Icard, T. (2022). On Pearl's Hierarchy and the Foundations of Causal Inference. ACM Books.
- Bennett, C. H. (1982). The thermodynamics of computation—a review. International Journal of Theoretical Physics, 21(12), 905-940.
- Demski, A., & Garrabrant, S. (2019). Embedded Agency. arXiv:1902.09469.
- Fallenstein, B., Taylor, J., & Christiano, P. (2015). Reflective Oracles: A Foundation for Classical Game Theory. arXiv:1508.04145.
- Feferman, S. (1962). Transfinite recursive progressions of axiomatic theories. Journal of Symbolic Logic, 27(3), 259-316.
- Garrabrant, S., et al. (2016). Logical Induction. arXiv:1609.03543.
- Gödel, K. (1931). Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I.
- Landauer, R. (1961). Irreversibility and heat generation in the computing process. IBM Journal of Research and Development, 5(3), 183-191.
- Pearl, J. (2009). Causality: Models, Reasoning, and Inference. 2nd ed. Cambridge.
- Rice, H. G. (1953). Classes of recursively enumerable sets and their decision problems. Transactions of the AMS, 74, 358-366.