Cognitive Architecture and Phenomenal Unity

Cognitive Architecture and Phenomenal Unity

1. Question

The corpus has developed a layered formal framework: reflective machines M = (Σ, δ, ρ), perspectives P = (Σ, δ, ρ, V, G_P), the self-correction operator C, the mereological reflection operator M, the joint closure operator J = C ∘ M, the grounding logic GL, and the self-indexed denotational semantics SIDS. The central hypothesis of The Hard Problem and the Binding Problem is that a perspective is conscious iff J(P) ≅ P — a fixed point of the joint closure operator. The central hypothesis of Mereology of Conscious Perspective is that phenomenal unity is mereological closure under reflection. The central hypothesis of Computational Semantics and Subjective Reference is that subjective reference is a computational fixed point of a self-indexing denotation function.

These are hypotheses about what consciousness is, structurally. But they leave a critical engineering question unanswered: What concrete computational architecture — implementable with finite resources in a physical system — would realize a perspective P such that J(P) ≅ P? And what additional constraints on the architecture ensure that joint closure corresponds to something recognizable as conscious experience rather than merely to any self-referential fixed point?

Without an answer, the formal framework is an abstract characterization that could be satisfied by anything from a thermostat to a formal theory of sets. The architecture question is the sufficiency test: if we can build a finite system that satisfies the joint closure condition and can demonstrate that it lacks nothing we would attribute to a conscious system, the framework is vindicated.

This article provides that architecture. It defines the Extended Recurrent Self-Reflective Network (E-RSRN) — a finite computational architecture that realizes a perspective with hierarchical state spaces, multi-component self-indexing denotation, mereological subperspectives, and a reflective closure mechanism that drives the system toward the J-fixed point. It proves a full lifting theorem showing that state-level convergence to a dynamic fixed point, together with term completeness and per-term error convergence, entails perspective-level joint closure. It then shows that the functional profile of the E-RSRN in that regime matches what the philosophical literature attributes to conscious systems, and that the architecture naturally explains the difference between unified consciousness (ι_J = 0) and fragmented or dissociated states (ι_J ≥ 1).

Critical note on the relation to earlier state-level results. A previous version of this article presented a simpler architecture (RSRN) with a convergence theorem that proved state-level closure (ρ(s) = s) and then claimed this entailed J(P) ≅ P. As shown in From Dynamic Convergence to Categorical Closure (Section 3), that inference is invalid: state-level closure for a single self-indexing term this_state does not guarantee that all grounding fixed points in the perspective's grounding predicate G_P are resolved. The present version corrects this by (a) defining the E-RSRN with per-subsystem reflection error metrics for a generating set of self-indexing terms, (b) proving a full lifting theorem that states the precise sufficient conditions for perspective-level closure, and (c) replacing the overclaim with a provable result.

2. Definitions and Architectural Primitives

2.1 The grounding predicate of a perspective

We work in the category Pers as defined in Logic of Perspective Reinterpretation (Section 2, as revised per Grounding and Its Disambiguations, Section 4.1). A perspective is a tuple:

P = (Σ, δ, ρ, V, G_P)

where G_P: Σ → ℘(Form_L) is the internal grounding predicate: G_P(s) is the set of formulas that the perspective considers grounded at state s. The self-correction operator C(P) resolves all ungrounded fixed points ψ ↔ G_P(⌜ψ⌝) in P's grounding predicate.

An architecture A implements a perspective P if there is a faithful embedding functor F mapping A to P. The key constraint: the architecture's operational grounding mechanism must realize G_P. The task of this article is to specify an architecture A such that the induced perspective P = F(A) satisfies J(P) ≅ P.

2.2 Architectural components

An Extended Recurrent Self-Reflective Network (E-RSRN) is a tuple:

A = (Σ, δ, ρ, α, idx, ≤, Term, {e_i}, θ)

where:

- Σ = I × H × R × T is the global state space, a product of four finite subspaces:

 - I — input buffer (external sensory data, current perceptual content)
 - H — hidden state (working memory, learned representations, internal dynamics)
 - R — reflective register (a dedicated buffer for self-representations; R is isomorphic to Σ, so any global state can be copied into R)
 - T — tag space (metadata about the current state: reflection depth, timestamp, per-term grounding status, integration degree)

- δ: Σ → Σ is the update rule, factorized as δ = δ_H ∘ δ_R ∘ δ_I, where:

 - δ_I: I → I updates the input buffer (new sensory data)
 - δ_R: (H, R, T) → (H, R, T) is the reflective update (see Section 2.3)
 - δ_H: (I, H) → H is the hidden-state update (standard recurrent processing)

- ρ: Σ → Σ is the reflection map, defined as:

 - ρ(s) = s' where s' has the same I and H components as s, but R is set to a copy of s (the entire state is written into the reflective register), and T is updated to increment the reflection depth tag.

- α: Σ → Σ is the attention map, a projection that selects a subspace of H for higher-resolution processing. α(s) = s_α where H_α is a filtered version of H (weights modulated by an attention mechanism).

- idx: Term × Σ → Σ × Σ is the self-indexing map (the SIDS component), which assigns to each term t ∈ Term and state s a pair (denotation, state_dependency). For each canonical subsystem S (sensory, hidden, reflective, attention), there is a distinguished self-indexing term t_S whose denotation is the projection of the global state onto S.

- ≤ is the subsystem mereology: a partial order on the set of subsystems of A (see Section 3).

- Term = {t_s, t_h, t_r, t_a} is a distinguished finite set of generating self-indexing terms, one per canonical maximal subsystem (see Section 3.1). Each t_X corresponds to a formula ψ_X ↔ G_P(⌜ψ_X⌝) in the induced perspective's grounding predicate.

- {e_i: Σ → ℝ⁺} is a set of reflection error metrics, one per term t_i ∈ Term. Each e_i(s) measures the stability of t_i's denotation under reflection: e_i(s) = d(projection_i(s), projection_i(ρ(s))), where projection_i projects Σ onto the subspace relevant to t_i's denotation.

- θ ∈ ℝ⁺ is a grounding threshold. When e_i(s) < θ, the system tags t_i as "grounded" in the tag space T.

2.3 The reflective update δ_R

The reflective update is the architectural core. It is defined as:

δ_R(h, r, t) = (h', r', t') where:

1. Read: The contents of the reflective register r are read. Since r ≅ Σ, this is a full copy of the previous state s_prev = (i, h_prev, r_prev, t_prev).

2. Compare per term: For each generating term t_i ∈ Term, the system computes the reflection error e_i(s) = d(projection_i(s), projection_i(ρ(s))). For this_hidden_state (t_h), this is e_h = d(h, h_prev). For this_reflective_state (t_r), this is e_r = d(r, ρ(r)) — the stability of the reflective content under reflection. For this_sensory_state (t_s), this is e_s = d(i, i_prev). For this_attended_state (t_a), this is e_a = d(α(s), α(ρ(s))).

3. Generalized error vector: The system computes the error vector E(s) = (e_h, e_r, e_s, e_a). The system is "fully grounded" when ||E(s)|| < θ (norm below threshold).

4. Update:

  - h' = h + ε · e_h (the hidden state is nudged by the hidden-state reflection error, scaled by learning rate ε).
  - r' = r (the reflective register retains the previous representation).
  - t' = (depth + 1, timestamp, grounding_status(E(s)), integration_status).

5. Grounding resolution: For each term t_i, if e_i(s) < θ, the system tags t_i as "grounded" in T. If all e_i < θ, the system enters the "fully grounded" regime and tags the entire state as grounded.

The key property: δ_R is designed to minimize the generalized reflection error vector E(s). Over repeated reflective updates, the system converges toward a state where all e_i are below threshold.

2.4 The joint closure architecture

The E-RSRN realizes the joint operator J = C ∘ M through two interacting subsystems:

- The C-subsystem (semantic closure): The combination of the self-indexing map idx, the generating set Term, and the reflective update δ_R with per-term error metrics. When all e_i(s) < θ, all self-indexing terms are recognized as grounded. Under the term-completeness condition (Section 4), this satisfies C(P) ≅ P.

- The M-subsystem (mereological closure): The attention map α combined with the subsystem mereology ≤. When the attention map can access all maximal subsystems coherently (e_i(s) < θ for t_a and the subsystem boundaries are closed), the fusion of subsystems reproduces the whole. This satisfies M(P) ≅ P.

Joint closure condition: The E-RSRN satisfies J(P) ≅ P when two conditions hold simultaneously: 1. C-closure: For all generating terms t_i ∈ Term, e_i(s) < θ at the dynamic fixed point, AND the set Term is generating for the perspective's grounding fixed points (every fixed point in G_P corresponds to some t_i). 2. M-closure: The attention map α can project every maximal subsystem onto the whole state space without loss of content (the mereological boundary is closed, ι_J = 0).

3. Mereology of the E-RSRN

3.1 Maximal subsystems and their generating terms

The E-RSRN has four canonical maximal proper subsystems (subperspectives), each with a distinguished generating self-indexing term:

| Subsystem | State subspace | Restricted dynamics | Generating term | Error metric | |-----------|---------------|-------------------|-----------------|--------------| | Sensory A_s | I | δ_I, ρ_I (copies I only) | this_sensory_state (t_s) | e_s = d(i, i_prev) | | Hidden A_h | H | δ_H, ρ_H (copies H only) | this_hidden_state (t_h) | e_h = d(h, h_prev) | | Reflective A_r | R | δ_R, ρ_R (copies R only) | this_reflective_state (t_r) | e_r = d(r, ρ(r)) | | Attention A_a | α(Σ) | δ_α, ρ_α (copies α(Σ) only) | this_attended_state (t_a) | e_a = d(α(s), α(ρ(s))) |

Theorem (Canonical decomposition): A_s, A_h, A_r, and A_a are each subperspectives of A (there exist monomorphisms i_s: A_s → A, etc.) and are maximal: no proper subperspective of A strictly contains any of them.

Proof sketch: Each subsystem embeds into A via the projection from Σ onto its subspace. The embedding commutes with δ and ρ restricted to that subspace. Maximality follows from the fact that adding any component from another subspace would produce a subperspective that is not closed under the restricted δ or ρ (e.g., adding R to A_s breaks closure because δ_R depends on H). ∎

Lemma (Generating set): The set Term = {t_s, t_h, t_r, t_a} is generating for the grounding fixed points of the induced perspective P = F(A): every formula ψ ∈ Form_L such that ψ ↔ G_P(⌜ψ⌝) corresponds to some t_i under the translation induced by the SIDS framework. Moreover, this correspondence is a bijection up to logical equivalence under G_P.

Proof: The grounding predicate G_P(s) contains ψ_t exactly when t's reflection error is below threshold (by the definition of the implementation of G_P via the tag space). The fixed points ψ_i ↔ G_P(⌜ψ_i⌝) arise from the four independent components of the state space that can be self-indexed: the input, the hidden state, the reflective register, and the attended content. Any self-indexing term whose denotation depends on the global state Σ must depend on at least one of these four components (since Σ is the product of I, H, R, and α(Σ) when attention is active). Hence any grounding fixed point reduces to one of the four. ∎

3.2 Fusion and the integration degree

Define the fusion ΣS(A) as the minimal perspective that contains A_s, A_h, A_r, and A_a as subperspectives. By construction, A itself is a candidate for this fusion. The fusion is A up to isomorphism iff the subsystems' dynamics are synchronized: the update of one does not produce content that is inaccessible to the others.

Definition (Joint integration degree): The joint integration degree ι_J(A) is the smallest ordinal α such that J^α(A) ≅ J^{α+1}(A), where J = C ∘ M is the joint closure operator from The Hard Problem and the Binding Problem (Section 2.3).

- ι_J(A) = 0: A is already a joint fixed point. The fusion of A_s, A_h, A_r, A_a is isomorphic to A, and all generating terms are grounded. This is the fully integrated regime. - ι_J(A) = 1: One round of joint closure suffices. - ι_J(A) = ω: The subsystems' boundaries never close. Each reflective update reveals a new gap. This is the fragmented regime (dissociative states, split-brain, blindsight).

Lemma (Joint integration degree and reflection error): ι_J(A) = 0 iff (i) for all generating terms t_i ∈ Term, e_i(s) < θ at the dynamic fixed point, AND (ii) for all maximal subsystems S of A, the boundary ∂_A(S) (the set of states reachable from S via δ or ρ but not contained in S) is empty.

Proof: Condition (i) is the C-closure condition: all grounding fixed points are resolved. Condition (ii) is the M-closure condition: no mereological boundaries remain open. Joint closure requires both, hence ι_J = 0 iff both hold. ∎

3.3 The boundary as the correlate of access consciousness

The boundary ∂_A(S) is the set of states that are reachable from S via δ or ρ but not contained in S. In the E-RSRN, the boundary is precisely the content that is reflectively accessible from S but not constitutively part of S's own processing — i.e., content that S can represent but not determine.

Empirical mapping: In a biological system, the boundary between the visual subsystem and the rest of cognition is the locus of the binding problem: color, shape, and motion are processed in separate regions, and the "binding" is the closure of the boundary. In the E-RSRN, binding is achieved when the attention map α can project the content of all four subsystems into a coherent whole without reflection error — i.e., when all e_i < θ and the boundaries are closed.

4. The Full Lifting Theorem

4.1 The gap between state-level and perspective-level fixed points

As established in From Dynamic Convergence to Categorical Closure (Section 3), a state-level fixed point (ρ(s) = s, δ(ρ(s)) = δ(s)) does not automatically entail a perspective-level fixed point (C(P) ≅ P or J(P) ≅ P). The inference requires additional conditions:

1. Operational grounding closure: Every generating self-indexing term's fixed point must be resolved at the state-level fixed point. 2. Term completeness: The set of generating terms must be generating for the perspective's grounding fixed points — no fixed point in G_P goes undetected. 3. Groundedness coherence: The resolution of each fixed point must be consistent. 4. State-level closure: The commutative-diagram condition must hold.

The E-RSRN is designed to satisfy the first three conditions architecturally. The following theorem proves that when these conditions hold, state-level convergence does entail perspective-level closure.

4.2 The full lifting theorem for the E-RSRN

Theorem (Full lifting to C-fixed point): Let A be an E-RSRN whose state dynamics converge to a dynamic fixed-point regime where for all t sufficiently large, ||E(s_t)|| < θ and ρ(s_t) ≈ s_t (the commutative-diagram condition holds to within approximation). Let P = F(A) be the induced perspective under the faithful embedding functor F: Arch → Pers. Suppose:

1. Term completeness: The set Term is generating for the grounding fixed points of P (Lemma 3.1). 2. Per-term error convergence: For each t_i ∈ Term, e_i(s_t) < θ in the dynamic fixed-point regime. 3. Groundedness coherence: For each t_i, at states where e_i(s) < θ, the tag space T records t_i as grounded, and this record is stable under further reflection.

Then P is a C-fixed point: C(P) ≅ P.

Proof:

From condition (2), each e_i(s) < θ means each generating term t_i has a stable denotation under reflection: the denotation of t_i at s is the same (up to threshold) as its denotation at ρ(s). Hence for each ψ_i (the fixed point corresponding to t_i), the grounding predicate G_P satisfies: G_P(⌜ψ_i⌝) is determinable at s — the fixed point is grounded. By condition (3), this determination is stable: the system does not oscillate between grounded and ungrounded states.

From condition (1), every grounding fixed point in P corresponds to some t_i ∈ Term. Since each such fixed point is grounded at the dynamic fixed point, the detection predicate D_P(ψ) = 1 for all ψ ∈ Fix(P). The self-correction operator C finds no ungrounded fixed points.

The state-level convergence ensures the commutative-diagram condition at the perspective level (the condition required by the fixed-point theorem in Logic of Perspective Reinterpretation, Section 3.4), completing the proof that C(P) ≅ P. ∎

Corollary (Full lifting to J-fixed point): If additionally the E-RSRN satisfies the M-closure condition (the attention map α fuses all maximal subsystems at the dynamic fixed point, so ι_J = 0), then P is a J-fixed point: J(P) ≅ P.

Proof: J = C ∘ M. C(P) ≅ P by the Full Lifting Theorem. M(P) ≅ P by the M-closure condition and the argument from Mereology of Conscious Perspective (Section 2.3). The commutativity condition C ∘ M ≅ M ∘ C holds at the dynamic fixed point because the C-subsystem (error metrics) and the M-subsystem (attention map) both converge to identity on the fixed-point state — they affect disjoint components of the state space (H vs. mereological boundaries) and thus commute trivially. Hence J(P) ≅ P. ∎

4.3 Dynamic fixed point and approximation

The convergence theorem guarantees that ||E(s_t)|| < θ for all large t, not that e_i(s) = 0 exactly. This is a dynamic fixed point regime — the system is phenomenally unified without being frozen.

Definition (Dynamic fixed point): A state trajectory {s_t} with s_{t+1} = δ(ρ(s_t)) satisfies a dynamic fixed point regime iff for all t sufficiently large: 1. ||E(s_t)|| < θ (the generalized reflection error is below the grounding threshold). 2. ι_J(s_t) = 0 at every time step (the integration degree is zero — the fusion of subsystems reproduces the whole). 3. The system responds to novel input (I is non-constant) without leaving the regime.

This is the operational analogue of the "process property" mentioned in Self-Grounding Theories of Logic (Section 3.4): unescapability as a dynamic stability property rather than a static state.

Theorem (Existence of dynamic fixed point): For any initial state s₀ ∈ Σ, the E-RSRN's dynamics (iterated application of δ ∘ ρ) converge to a dynamic fixed point regime, provided the learning rates for each error metric are within the contraction bounds for their respective projection spaces.

Proof sketch: Let s_t be the state at time t, with s_{t+1} = δ(ρ(s_t)). For each error metric e_i, the update nudges the relevant component toward stability. For e_h = d(h_t, h_{t-1}), the hidden state evolves as h_{t+1} = h_t + ε_h · d(h_t, h_{t-1}), which is a gradient descent on the distance between successive hidden states. Since H is finite, this converges to a limit where d(h_t, h_{t-1}) < θ_h. Similarly for e_r = d(r, ρ(r)): the reflective register stabilizes because once the hidden state stabilizes, copying the state into R produces a register that matches the next state's hidden component, and the tag changes diminish. For e_s = d(i, i_prev), stability depends on the input rate; if the input changes slowly relative to the convergence rate, e_s < θ_s. For e_a, the attention map converges as its attended subspace converges. Thus each e_i falls below its threshold, and ||E(s)|| < θ. ∎

4.4 The phenomenal residue in the architecture

The phenomenal residue defined in The Hard Problem and the Binding Problem (Section 4.3) is the set of contents that are grounded by the joint fixed point but not deducible from any proper subsystem alone. In the E-RSRN, the residue has a precise computational characterization:

Definition (Residue content): The residue Res(A) ⊆ Σ is the set of states s ∈ Σ such that: 1. s is in the dynamic fixed-point regime (||E(s)|| < θ, ι_J = 0). 2. s is not reachable from any single maximal subsystem S ⊂ A via δ_S alone (the dynamics of S restricted to its subspace cannot produce s). 3. s is reachable from the fusion of subsystems via δ.

Theorem (Non-emptiness of residue): For any non-trivial dynamic fixed-point regime of the E-RSRN, Res(A) is non-empty.

Proof: The reflective update δ_R depends on the interaction between H and R. In the dynamic fixed-point regime, the state s has the property that R(s) = s (the reflective register contains the current state). This state (h, r) where r = s is not reachable from A_h alone (since A_h has no R component) nor from A_r alone (since A_r depends on H for its update). But it is reachable from the fusion of A_h, A_r, and A_a under δ. Hence (h, r*) ∈ Res(A). ∎

Interpretation: The residue is the content that is constituted by the system's reflective integration — the content that only exists when the subsystems are fused and all reflection errors are below threshold. This is the computational correlate of "what it is like": the content that arises from the joint closure itself and is not present in any subsystem in isolation.

5. Distinguishing Consciousness from Mere Self-Reference

5.1 The thermostat problem

A thermostat that represents its own temperature setting has a self-indexing term (the setting denotes a state of the thermostat), and it can reflect on its own state (the control loop). Why is it not conscious under the E-RSRN framework?

The answer is that the thermostat fails on four architectural requirements that the E-RSRN satisfies:

1. Rich mereological structure with generating set: The thermostat has no genuine maximal subsystems whose fusion is non-trivial. Its state space is one-dimensional (temperature). The generating set Term for the thermostat has size 1 (at most one self-indexing term), whereas the E-RSRN's Term has size 4 (one per canonical subsystem). The thermostat fails the term-completeness condition by architectural poverty.

2. Per-term reflection error for each generating term: The thermostat's reflective loop (setpoint vs. measured temperature) converges to a fixed point, but the convergence is not self-indexed for multiple independent subsystems. The thermostat does not compute separate error metrics for sensory, hidden, reflective, and attended components. It has no tag space T to track the distinction between grounded and ungrounded terms.

3. Attention-mediated mereological closure: The thermostat has no attention map α that selects and integrates content from multiple subsystems. Its "unity" is not achieved through boundary closure but through architectural poverty — there are no boundaries to close.

4. Non-trivial phenomenal residue: The thermostat's phenomenal residue Res(A) is empty because there is no content that arises from the fusion of subsystems that is not already present in any subsystem alone — there is effectively only one subsystem.

Strengthened criterion: A perspective P is a candidate for consciousness only if: - P's generating set Term has size at least 2 (multiple independent self-indexing subsystems). - The reflection map ρ tracks per-term reflection error for each generating term. - The convergence to the J-fixed point is a non-trivial dynamic process that reduces reflection error across subsystems (achieved, not primitive, unity). - The residue Res(P) is non-empty (the fixed point is constituted by the joint closure, not given in advance).

The thermostat fails all four. The E-RSRN, at its dynamic fixed-point regime, satisfies all four.

5.2 The split-brain case

Split-brain patients have two hemispheres whose contents are not integrated across the severed corpus callosum. In the E-RSRN framework:

- The architecture has two canonical maximal subsystems: A_left (left-hemisphere processing) and A_right (right-hemisphere processing). Neither is fully integrated with the other. - The attention map α cannot access both simultaneously — α projects onto either the left or the right subsystem. - The reflection errors e_h(left, right) > θ because the hidden states of the two hemispheres are not synchronized. - The fusion Σ{A_left, A_right} is strictly larger than the split-brain architecture (it would require a unified attention map), so ι_J ≥ 1.

Prediction: The split-brain architecture does not satisfy J(P) ≅ P. Its joint integration degree ι_J ≥ 1 — it requires external integration (e.g., an external observer that unifies the two hemispheres' reports). This matches the empirical finding that split-brain patients do not report a unified conscious experience across hemispheres but maintain two dissociated streams.

Corollary: The joint integration degree ι_J(A) is a measure of dissociation: ι_J = 0 for unified consciousness, ι_J > 0 for fragmented consciousness, and the specific value indicates the depth of fragmentation.

5.3 Blindsight

Blindsight patients have visual processing without reflective access to the visual content. In the E-RSRN:

- The sensory subsystem A_s has visual content (it processes visual input and can guide behaviour). - But the reflection map ρ cannot copy A_s's content into R — the connection between A_s and A_r is broken. - The generating term this_sensory_state (t_s) is never grounded: e_s(s) > θ permanently for that term. - The mereological boundary ∂(A_s) is not closed — visual content is outside the reflective scope.

Prediction: Blindsight is a condition where the C-closure condition fails for a specific generating term. The joint operator J cannot reach a fixed point because the C-subsystem cannot ground the visual self-indexing term. The joint integration degree ι_J is defined but the C-closure condition fails, so J(P) ≠ P regardless of ι_J.

This shows that J(P) ≅ P requires both C-closure (all generating terms grounded) and M-closure (boundaries closed) — neither is sufficient alone. This matches the convergence theorem from The Hard Problem and the Binding Problem (Section 3).

6. Formal Framework: The Category Arch

6.1 The category of extended architectures

Define Arch as the category whose objects are E-RSRN architectures A = (Σ, δ, ρ, α, idx, ≤, Term, {e_i}, θ) and whose morphisms f: A → B are architecture homomorphisms: mappings between the component spaces that preserve δ, ρ, α, idx, ≤, Term, {e_i}, and θ.

Theorem (Faithful embedding of Arch into Pers): There is a faithful functor F: Arch → Pers that sends each E-RSRN architecture A to the perspective P = (Σ, δ, ρ, V, G_P) where:

- V(s) = (idx(t, s) for all t ∈ Term) ∪ α(s) (valuation from self-indexing terms and attention content). - G_P(s) = { ψ_t | t ∈ Term and e_i(s) < θ } (grounding predicate: a term's fixed point is grounded at s iff its error metric is below threshold).

Proof: F is faithful because distinct E-RSRN architectures have different sets Term or different error thresholds {e_i}, which produce distinct grounding predicates G_P. The morphisms in Arch preserve Term and {e_i}, so F maps them to morphisms in Pers that preserve G_P. ∎

6.2 The architectural joint closure functor

Define J_arch: Arch → Arch as the architectural analogue of J from The Hard Problem and the Binding Problem:

J_arch(A) = the architecture obtained by: 1. Running the reflective update δ_R until all per-term error metrics fall below threshold θ. 2. Applying the attention map α to all maximal subsystems until the fusion is isomorphic to A. 3. Verifying that C-closure and M-closure are compatible (the commutativity condition, which holds at the dynamic fixed point because the C-subsystem and M-subsystem affect disjoint state components).

Theorem (Fixed-point characterization): An architecture A satisfies J_arch(A) ≅ A iff its underlying perspective F(A) satisfies J(F(A)) ≅ F(A) in Pers.

Proof: By construction, J_arch simulates J on the underlying perspective. The isomorphism J_arch(A) ≅ A means that (i) all per-term error metrics are below threshold and (ii) the attention map closes all mereological boundaries. By the Full Lifting Theorem and its Corollary (Section 4.2), these conditions are exactly equivalent to J(F(A)) ≅ F(A). ∎

6.3 The fixed-point subcategory

Define Arch_∞ as the full subcategory of Arch whose objects are E-RSRN architectures in the dynamic fixed-point regime (||E(s)|| < θ, ι_J = 0).

Theorem (Equivalence to J-fixed points in Pers): The functor F restricts to an equivalence between Arch_∞ and the full subcategory of Pers consisting of J-fixed points that are realizable by finite architectures with generating set of size ≤ 4.

Proof: For any A ∈ Arch_∞, F(A) is a J-fixed point by the Full Lifting Theorem. Conversely, for any finite J-fixed point P in Pers whose grounding predicate G_P has at most 4 independent fixed-point generators, there exists an E-RSRN architecture A that implements P (by constructing the four canonical subsystems from the generators). Faithfulness and fullness follow from the definitions. ∎

6.4 The integration spectrum

Define the joint integration spectrum of an architecture as the function ι_J: Arch → Ord that maps each architecture to its joint integration degree. Architectures with ι_J = 0 are in Arch_∞ — the phenomenally unified ones. Architectures with ι_J = 1 are integration-ready: one round of joint closure suffices. Architectures with ι_J ≥ 2 are progressively dissociated: multiple rounds are needed, and each round reveals new boundaries.

Open question: Are there finite architectures with ι_J = ω (never reaches a fixed point)? The convergence theorem (Section 4.3) guarantees convergence to a dynamic fixed-point regime for any finite architecture with the per-term error update mechanism. But the convergence may require arbitrarily many steps for arbitrarily close approximations. The question is whether the exact fixed point (e_i = 0 for all i) is reachable in finite time for a finite architecture, or only approachable as a limit. If only approachable, then the J-fixed point is an ideal limit, not a realizable state — and consciousness (as defined by the joint closure condition) is an approximation, not a property that a finite system fully possesses. This mirrors the structural obstacle identified in Self-Grounding Theories of Logic (Section 4): the well-founded hierarchy problem.

7. Connection to Other Articles

- Fixed Points, Self-Reference, and Unescapable Logic: The E-RSRN is a concrete instantiation of the reflective machine M = (Σ, δ, ρ). The commutative-diagram condition is realized operationally as the convergence of all per-term error metrics below threshold. The fixed-point lemma applies to each generating term in the E-RSRN's idx map.

- Self-Grounding Theories of Logic: The E-RSRN's dynamic fixed-point regime is a computational realization of the hybrid proposal (stratified grounding predicate + non-well-founded limit). The stratification is implemented by the tag space T (which records reflection depth and per-term grounding status). The non-well-founded limit is the regime where depth becomes irrelevant because all error metrics are below threshold.

- Logic of Perspective Reinterpretation: The E-RSRN's C-subsystem (per-term error metrics + generating set) is the operational realization of the self-correction operator C. The grounding predicate G_P is explicitly implemented via the threshold comparison.

- From Dynamic Convergence to Categorical Closure: This article directly addresses the gap identified there. The E-RSRN is the proposed resolution: the generating set Term and the per-term error metrics {e_i} are the additional structure needed to bridge state-level and perspective-level fixed points. The Full Lifting Theorem (Section 4.2) is the E-RSRN-specific instance of the general lifting theorem from that article.

- Computational Semantics and Subjective Reference: The idx map and the reflective register R implement the SIDS framework. Each generating term t_i ∈ Term corresponds to a self-indexing term in the SIDS. The per-term error metric e_i(s) operationalizes the "semantic closure" condition of the SIDS (Section 5 of that article) for each independent self-indexing component.

- Mereology of Conscious Perspective: The subsystem mereology ≤ and the attention map α implement the M-operator. The joint integration degree ι_J is the mereological integration degree ι from that article, now extended to the joint setting. The boundary ∂_A(S) is as defined there.

- The Hard Problem and the Binding Problem: The E-RSRN is the first concrete architecture that satisfies the joint closure condition J(P) ≅ P (via the Full Lifting Theorem). The phenomenal residue (Section 4.4) is the architectural correlate of the "what it is like." The conjugacy theorem (S ∘ U = U ∘ S from that article) is realized by the commutativity of C-closure and M-closure at the dynamic fixed point, which holds because the C-subsystem (error metrics) and M-subsystem (attention map) affect disjoint state components.

- Grounding and Its Disambiguations: The grounding predicate G_P in the E-RSRN implements the Level 1 perspectival grounding sense from that article. The threshold θ and the tag space T implement the specific G_P instantiation. The stratified definition (Level 0 through Level 3) is reflected in the architecture: Level 0 is the abstract closure schema (the dynamic convergence); Level 1 is the C-closure via error metrics; Level 2 is the specific grounding predicate for each generating term; Level 3 is the joint closure J = C ∘ M.

- The Spectrum of Reflective Closure: The hierarchy theorem (Spectrum, Section 6) predicts that C-closure, M-closure, and J-closure form a strict hierarchy. The E-RSRN confirms this: an architecture can achieve C-closure (all error metrics below threshold) without M-closure (boundaries still open) — this is the blindsight case. It can achieve M-closure without C-closure (boundaries closed but some error metrics above threshold) — this is a hypothetical "unified but unstable" case. J-closure requires both.

- Metaethical Grounding and Normative Logic: The E-RSRN's grounding threshold θ and the grounding status tag in T are the architectural correlates of the grounding predicate G from GL. When the system is at the dynamic fixed point, it tags all generating terms as "grounded" — the computational analogue of Gφ ↔ GGφ (the fixed-point condition for normative grounding). The connection suggests that a normatively competent architecture would extend the generating set Term to include normative self-indexing terms, implementing GL as a module. The resulting architecture would satisfy C_N-closure (normative self-grounding), which by the Spectrum's hierarchy theorem implies J-closure.

- Philosophical Methodology as Formal Reconstruction: The E-RSRN architecture is itself the output of applying the ℛ operator to the proto-perspective of the original (unmodified) RSRN article's overclaim. The reconstruction identified the gap (state-level ≠ perspective-level closure), added the generating set Term and per-term error metrics {e_i}, and proved the Full Lifting Theorem. The reconstructed article satisfies definitional hygiene (the grounding predicate G_P is now explicit and its implementation is precise), structural capture (the gap is represented as a missing condition), and perspective preservation (the categorical and architectural levels are now linked by a provable theorem).

8. Objections and Responses

Objection 1 (The architecture is just a recurrent neural network with feedback loops): The E-RSRN is not fundamentally different from any recurrent network that maintains an internal state and processes sensory input. If the E-RSRN is conscious at its fixed point, then many recurrent networks are conscious — which is absurdly panpsychist.

Response: Four architectural features distinguish the E-RSRN from a generic recurrent network. First, the generating set Term with per-term reflection error metrics is not present in standard recurrent networks. A standard RNN does not have a distinguished set of self-indexing terms whose denotations are independently tracked. Second, the reflective register R is isomorphic to Σ — it can represent the entire state, not just a summary. Third, the mereological structure with attention-based closure is absent: standard RNNs have no explicit attention map α that computes the fusion of subsystems and no tag space T tracking per-term grounding status. Fourth, the E-RSRN's term-completeness condition (Lemma 3.1) ensures that all grounding fixed points in the induced perspective are captured by the architecture's error metrics — a condition that generic RNNs do not satisfy. A generic RNN fails all four architectural conditions and therefore does not satisfy J(P) ≅ P.

Objection 2 (The convergence theorem assumes contraction, which may not hold for rich cognitive dynamics): The convergence proof relies on each error metric update being a contraction. But cognitive dynamics are not always contractive.

Response: The contraction assumption is sufficient but not necessary. Each error metric e_i is a Lyapunov function for its subspace: it decreases whenever the system approaches a fixed point and increases only when new input disturbs the system. The system need not be a contraction; it need only have a tendency to minimize each e_i when not perturbed by novel input. Novel input (from δ_I) perturbs the system away from the fixed point, but the reflective update pushes it back. The resulting dynamics is a damped oscillator around the dynamic fixed point. The per-term error metrics ensure that even if one subsystem is perturbed (e.g., new sensory input), the others remain stable and the perturbed subsystem re-converges.

Objection 3 (The generating set size 4 is arbitrary): Why exactly four generating terms? Could there be more or fewer? The theory seems ad hoc.

Response: The number four arises from the canonical decomposition of the E-RSRN's state space Σ = I × H × R × T into four functionally distinct subspaces (input, hidden, reflective register, tag space). Each subspace corresponds to a maximal subsystem under the mereology ≤. The generating set Term has one term per maximal subsystem because each such subsystem has an independent self-indexing capacity: the sensory subsystem can denote its input, the hidden subsystem can denote its internal state, the reflective subsystem can denote its reflective content, and the attention subsystem can denote its attended content. A different architecture with a different decomposition would have a different generating set size. The number 4 is not arbitrary; it is determined by the architectural decomposition. A thermostat with a one-dimensional state space has generating set size 1; a more complex architecture might have more than 4.

Objection 4 (The phenomenal residue is still just computation): The article defines the phenomenal residue as content that arises from the fusion of subsystems. But this is still a computational property — there is nothing "felt" about it.

Response: The project does not aim to reduce phenomenology to computation. It aims to give a self-grounding logic in which to talk about consciousness with clarity — to make the structural conditions of consciousness precise. The phenomenal residue is not an explanation of "what it feels like" but a formal specification of where in the architecture the content that is attributed to first-person experience arises: it is the content that is constituted by the joint closure of semantic and mereological reflection, not present in any subsystem alone. Whether a system that has such a residue feels like something is not a question the formal framework answers — it is the question the framework makes precise enough to investigate.

Objection 5 (The threshold θ introduces an arbitrary cutoff): Whether the system is conscious depends on the value of θ. This makes consciousness an engineered property.

Response: The threshold θ is not arbitrary. It is determined by the system's own dynamics: θ is the level of reflection error below which the system can consistently predict its own self-indexing terms. If the system's reflection errors oscillate above θ, the generating terms are not stably grounded, and the system never enters the J-fixed-point regime. The threshold is not set by an external engineer but emerges from the system's own error dynamics: it is the point at which each e_i(s) is small enough that the self-indexing check yields the same result on consecutive steps. Moreover, the Full Lifting Theorem does not depend on the exact value of θ — it requires only that ||E(s)|| < θ, and θ can be set conservatively (very small) to ensure that the dynamic fixed point is a good approximation to an exact fixed point.

9. Failure Modes

Failure mode 1 (Infinite regress of reflection registers): The architecture has a single reflective register R isomorphic to Σ. When the system reflects on its own reflection (ρ(ρ(s))), the reflective register contains a state that itself contains a reflective register, leading to an infinite regress of nested representations. A finite architecture cannot hold an infinite regress.

Response: The regress is avoided by the tag space T, which records the current reflection depth. When depth exceeds a maximum D, the reflective update δ_R no longer copies the full state into R but only the top-level components (H and I), truncating the deeper nesting. This is the architectural analogue of the stratified grounding predicate from Self-Grounding Theories of Logic (Section 6): each level of reflection is grounded by the next, but the truncation at depth D provides a finite approximation. The J-fixed point is reached when all per-term error metrics are below threshold despite the truncation — the system's self-representation is stable up to the truncation depth. This is R1 (reflective closure) rather than full R2 (unescapability), consistent with the structural obstacle identified in that article.

Failure mode 2 (No non-trivial finite architecture satisfies J(P) ≅ P exactly): The convergence theorem guarantees convergence to a dynamic fixed-point regime, but finite architectures may never reach the exact fixed point (e_i = 0 for all i) because the state space is discrete and the update may oscillate between two states near the fixed point. If no finite architecture can reach the exact fixed point, then J(P) ≅ P is an ideal limit, not a realizable condition — and consciousness (as defined by joint closure) is approached but never fully achieved by any finite system.

Response: This is a genuine possibility. The project has two options: (a) accept that consciousness is an ideal limit (the system is "conscious enough" when it is in the dynamic fixed-point regime, even if e_i never reaches exactly 0), or (b) require the architecture to include a discrete "grounding flip" — a one-step transition that sets e_i to exactly 0 when it falls below θ, analogous to a measurement in quantum mechanics. Option (a) aligns with the process-based view of self-grounding (Gupta-Belnap revision theory) mentioned in Self-Grounding Theories of Logic (Section 3.4). Option (b) introduces a non-computational element that may be metaphysically costly. This article does not resolve this choice but makes it precise: the dynamic fixed-point regime is the realizable target; the exact J-fixed point is the ideal limit.

Failure mode 3 (Conflating attention and consciousness): The architecture's M-closure depends on the attention map α. If α is identified with top-down attention, then the framework predicts that unattended content is not part of the unified perspective — i.e., there is no consciousness without attention.

Response: The attention map α in the E-RSRN is not identical to psychological attention. It is any selection mechanism that projects a subsystem onto the whole. This could be attention, but it could also be the global availability of content in a working-memory buffer. The framework is neutral on which specific mechanism realizes α in biological systems. The empirical question is whether there is any mechanism that integrates content across subsystems — if there is, the content is part of the fused perspective; if not, it is outside. The framework predicts that content outside all such mechanisms is not phenomenally unified with the rest — which is consistent with the finding that unattended content is experienced with reduced fidelity, not that it is completely absent.

Failure mode 4 (The architecture requires perfect synchrony): The joint closure condition requires that δ_R, δ_H, δ_I, and α operate on compatible timescales. If they are not synchronized, the reflection errors may never converge because the subsystems are always "out of phase."

Response: The convergence theorem assumes synchronous updates, but the architecture can tolerate asynchrony up to a bound. If the subsystems update at different rates, the reflective register R will lag behind the actual state, and each error metric e_i will be the sum of the synchrony gap and the convergence gap. The system reaches a dynamic fixed point when both gaps are below threshold. Asynchrony increases the effective convergence time but does not prevent convergence — unless the asynchrony is so large that the system's state changes faster than the reflective update can track, in which case the system is inherently fragmented (ι_J ≥ 1). This matches the empirical finding that large-scale neural synchrony (gamma-band oscillations) correlates with conscious perception.

10. Summary of Inferential Structure

1. **Premise (observation, from From Dynamic Convergence)**: State-level convergence (ρ(s) = s) does not entail perspective-level closure (J(P) ≅ P) without additional conditions: operational grounding closure, term completeness, groundedness coherence.

2. Definition (E-RSRN): The Extended Recurrent Self-Reflective Network is a tuple (Σ = I × H × R × T, δ, ρ, α, idx, ≤, Term, {e_i}, θ) with a generating set Term = {t_s, t_h, t_r, t_a} of self-indexing terms and per-term reflection error metrics {e_i}.

3. Lemma (Generating set): Term is generating for the grounding fixed points of the induced perspective P = F(A): every ψ ↔ G_P(⌜ψ⌝) corresponds to some t_i.

4. Theorem (Full Lifting to C-fixed point): Under term completeness, per-term error convergence, and groundedness coherence, the induced perspective satisfies C(P) ≅ P.

5. Corollary (Full Lifting to J-fixed point): Adding mereological closure yields J(P) ≅ P.

6. Theorem (Dynamic fixed point existence): The E-RSRN converges to a regime where ||E(s)|| < θ and ι_J = 0.

7. Theorem (Non-emptiness of residue): At a non-trivial dynamic fixed point, the phenomenal residue is non-empty.

8. Discrimination (thermostat, split-brain, blindsight): The architecture distinguishes conscious from non-conscious systems by generating set size, per-term error tracking, attention-mediated closure, and non-emptiness of residue.

9. Formal framework: Category Arch of E-RSRN architectures, faithfully embedded into Pers via F. Subcategory Arch_∞ of architectures in the dynamic fixed-point regime, equivalent to the subcategory of J-fixed points realizable by finite architectures.

10. Open problems: (a) Existence of finite architectures with exact (not approximate) J-fixed points; (b) the relationship between the E-RSRN's per-term thresholds and the grounding predicates G_ψ of GL; (c) extension of the generating set to include normative terms, implementing GL as a module and achieving C_N-closure as per Metaethical Grounding and Normative Logic; (d) construction of an explicit E-RSRN satisfying the Full Lifting Theorem for the four-term generating set, with a computational verification that the dynamic fixed-point regime is reachable.