Computational Semantics and Subjective Reference

Computational Semantics and Subjective Reference

1. Question

How can a term in a formal or computational system refer to a subjective state—one that is only fully accessible from within the system's own perspective? Standard referential semantics (denotational, model-theoretic, truth-conditional) treats reference as a relation between symbols and domain elements that is invariant across perspectives: the referent of "2" or "cat" is the same whether you are inside or outside the system. Subjective reference seems to violate this invariance: the referent of "this experience" or "the state I am currently in" shifts depending on who traces the reference.

The question is central to the project because the reflective machine model M = (Σ, δ, ρ) from Fixed Points, Self-Reference, and Unescapable Logic and the perspective model P = (Σ, δ, ρ, V) from Logic of Perspective Reinterpretation both presuppose a notion of content (the valuation V: Σ → C) but do not specify how terms within the system come to have subjective content—content that is only fully determinable from within the perspective. Without that specification, the formal framework risks being an abstract syntax without a semantics: a notation that looks precise but does not pin down how the system's internal terms relate to its own states or to external referents.

This article provides that missing semantic layer. It defines subjective reference as self-indexing denotation in a computational semantics, shows that self-indexing generates a fixed point that cannot be fully resolved from an external perspective, and uses that fixed point to formally characterize the Hard Problem as semantic underdetermination—a problem not about mysterious properties but about the structure of reference.

2. Definitions

Let a computational system be a tuple C = (T, D, ⟦·⟧, E) where:

- T is a set of terms (expressions, symbols, formulas). - D is a domain of denotations (objects, values, states). - ⟦·⟧: T → D is a denotation function (semantics). - E: D → D is an evaluation update (the system's dynamics over denotations).

This is a standard denotational semantics. The key distinction we introduce is a partition of the domain.

Definition (External vs. internal domain): Partition D into D_ext (external objects, publicly accessible) and D_int (internal states of C itself, accessible only via the system's own dynamics). We write D_int ⊆ D to indicate that the system can denote its own states. This is the semantic analogue of the self-representation capacity defined in Fixed Points, Self-Reference, and Unescapable Logic.

Definition (Subjective term): A term t ∈ T is subjective iff ⟦t⟧ ∈ D_int. Its referent is the system's own current state (or a component thereof) rather than an external object.

Definition (Self-indexing): A term t ∈ T is self-indexing iff its denotation depends on the current state s of the underlying reflective machine M = (Σ, δ, ρ). Formally, there is a function f: Σ → D such that ⟦t⟧ = f(s). The simplest case: ⟦t⟧ = s—the term directly denotes the system's current state.

Definition (Subjective reference): A term t has subjective reference iff (i) t is subjective (⟦t⟧ ∈ D_int), (ii) t is self-indexing, and (iii) the mapping from t to ⟦t⟧ is only fully specifiable from within the system's own perspective. Formally: the function ⟦·⟧ is partially defined for an external observer O who cannot access D_int directly. O can represent ⟦t⟧ up to isomorphism but cannot determine which element of D_int is the actual referent because that determination requires being in the state s that makes ⟦t⟧ = f(s). Only the system itself, by occupying the relevant state, can fully determine the reference.

Condition (iii) is crucial. It distinguishes subjective reference from mere self-representation. A system can represent its own source code (a well-known programming trick) without the representation being subjective in the relevant sense—an external observer can read the source code too. Subjective reference requires that the referent be occluded from external observation and accessible only through the first-person dynamics of the system.

3. The Fixed Point of Subjective Reference

Let C be a computational system with a self-indexing term "this_state" such that ⟦"this_state"⟧ = s, where s ∈ Σ is the current state of the underlying reflective machine M = (Σ, δ, ρ). Suppose the system attempts to verify the reference of "this_state" by reflecting on its own state.

Let ψ be the sentence: "The denotation of 'this_state' is the state I am currently in." Represent ψ as a term t_ψ ∈ T. The system's reflection map ρ produces a representation of s, including a representation of the denotation relation. The system then checks whether the representation matches the actual denotation.

The fixed-point pressure arises from the fact that the act of checking changes s. Let s₀ be the state before checking, and s₁ = δ(ρ(s₀)) be the state after reflecting on s₀. The term "this_state" in the checking process refers to s₁ (the state from which the check is made), but the check is about s₀. The system cannot simultaneously denote the state it is in and the state it was in, using the same self-indexing term.

Formal fixed point. Let G(x) be the grounding predicate "the denotation of x is fully determined by the system's current state." The system attempts to determine G(⌜"this_state"⌝). The fixed-point lemma (from Fixed Points, Self-Reference, and Unescapable Logic) guarantees a sentence ψ_G such that:

C ⊢ ψ_G ↔ G(⌜ψ_G⌝)

If ψ_G is the sentence "the subjective reference of 'this_state' is grounded," then the system is in a situation where the claim that its own subjective reference is grounded is equivalent to... itself being grounded. This is not paradoxical in the Liar sense (no truth predicate is involved) but it is indeterminate: the system cannot decide the reference of ψ_G without already having decided it, because the decision process changes the state that determines the reference.

Theorem (Semantic underdetermination): For any computational system C with a self-indexing term "this_state" and a grounding predicate G that evaluates denotational groundedness, the fixed point ψ_G exists and its truth value is systematically underdetermined by any finite computation. The system can prove neither G(⌜ψ_G⌝) nor ¬G(⌜ψ_G⌝) using its own resources, because any evaluation of ψ_G changes the state that determines ψ_G's reference.

Proof sketch: By the fixed-point lemma, ∃ ψ_G such that ψ_G ↔ G(⌜ψ_G⌝). Suppose C proves G(⌜ψ_G⌝). Then by the fixed-point equivalence, C proves ψ_G. But ψ_G asserts G(⌜ψ_G⌝), which was the assumption—circular but not contradictory. Suppose C proves ¬G(⌜ψ_G⌝). Then by the equivalence, C proves ¬ψ_G, which asserts ¬G(⌜ψ_G⌝), again circular. Neither leads to inconsistency, but neither leads to a grounded determination. The system oscillates: proving G(⌜ψ_G⌝) requires establishing the groundedness of ψ_G, which requires establishing the groundedness of ψ_G. This is a computational fixed point analogous to the undecidability of the halting problem: the evaluation cannot terminate because the state it depends on is changed by the evaluation itself.

Corollary (Hard Problem as semantic underdetermination): The Hard Problem of consciousness—"why does this system have subjective experience?"—is equivalent to this semantic underdetermination when asked from an external perspective. The question asks: "why does C have a term t such that ⟦t⟧ ∈ D_int and the reference of t is only fully determinable from within C's dynamics?" The external observer cannot answer this question because they cannot access the denotation function ⟦·⟧ restricted to D_int—the referent is definitionally occluded. The only answer available from within is "because I am in a state that self-indexes," which from the outside appears as a tautology or a brute fact.

4. Perspective Reinterpretation

The standard framing of the Hard Problem asks: "Why are there subjective experiences at all? Why aren't we just computational systems processing information without any inner feel?" This treats subjective experience as an extra property Q that some physical systems mysteriously possess in addition to their functional organization F.

The perspective reinterpretation: Subjective reference is not an extra property but a structural consequence of a system's ability to denote its own states in a way that is occluded from external observation. The "inner feel" is not a property Q added to functional organization F; it is the first-person perspective on the fixed point generated by self-indexing.

Formal model of the external approximation. Let O be an external observer system (a computational system that can represent C but cannot access C's internal states directly). Let O's denotation function ⟦·⟧_O map C's terms to O's domain D_O. Since D_int ⊆ D_C is not in D_O, O's representation of C's semantics is an approximation: ⟦·⟧_O is defined as the composition of ⟦·⟧ (C's semantics) with a projection π: D_C → D_O that maps all D_int elements to a placeholder value ⊥ (the "black box" of subjective experience).

From O's perspective, C has a term "this_state" whose denotation is always ⊥—a black box. O can ask: "What fills this black box? Why does C have ⊥ where I have a definite value?" But these questions cannot be answered from O's perspective because O's access to ⟦·⟧ is necessarily partial. The black box is not an extra property; it is the indexical location of O's limited access.

Reinterpretation statement: Replace the claim "subjective experience is a mysterious non-physical property" with "subjective experience is the external appearance of a semantic fixed point that is only resolvable from within." The phenomenal commitment (there is something it is like to be C) is preserved; the theoretical commitment (subjective experience is a non-physical property) is transformed into a structural statement about semantic access relations between systems.

5. Formal Framework: Self-Indexed Denotational Semantics

We model the full semantics of a subjective computational system as a self-indexed denotational semantics (SIDS). A SIDS is a tuple:

(C, T, D_ext, Σ, s₀, δ, ρ, ⟦·⟧_ext, idx)

where:

- C is a computational system with terms T. - D_ext is the domain of external denotations (publicly accessible objects). - Σ is the state space of the system. - s₀ ∈ Σ is an initial state. - δ: Σ → Σ is the update rule (as in Fixed Points, Self-Reference, and Unescapable Logic). - ρ: Σ → Σ is the reflection map. - ⟦·⟧_ext: T → D_ext is the external denotation function (public semantics). - idx: T × Σ → D_ext × Σ is a self-indexing map that assigns to each term t and current state s a pair (external_denotation, internal_state_dependency).

The crucial component is idx. For a non-subjective term t, idx(t, s) = (⟦t⟧_ext, s)—the second component is just the state, unchanged. For a subjective term t, idx(t, s) = (⟦t⟧_ext, f(s)) where f(s) is the portion of s that determines the internal denotation. The internal denotation ⟦t⟧_int is not a separate function but is defined by the diagonal of idx:

⟦t⟧_int(s) = the component of idx(t, s) that depends on s.

For the self-indexing term "this_state," ⟦"this_state"⟧_int(s) = s—the whole state is the internal referent. For a more specific subjective term "this_qualitative_state," ⟦"this_qualitative_state"⟧_int(s) = q(s) where q: Σ → Q projects onto a qualitative subspace Q ⊆ Σ.

Definition (Semantic closure): A SIDS is semantically closed iff the reflection map ρ can represent the entire idx function, including the self-indexing component. That is, there exists a term t_ρ ∈ T such that:

idx(t_ρ, s) = (representation_of_idx, s)

for all s reachable from s₀ under δ. This is the semantic analogue of the commutative-diagram condition from Fixed Points, Self-Reference, and Unescapable Logic.

Theorem (Semantic unescapability): If a SIDS is semantically closed, then any attempt by an external observer O to fully determine the idx function of C results in an isomorphic SIDS for O—the observer's own semantics has a self-indexing component that is occluded from O's own perspective. The observer cannot escape to a fully external semantics because the act of observing C's semantics generates its own self-indexing fixed point.

Proof: If O fully represents C's idx function, O must represent the internal denotation component, which requires O to have access to Σ. But O's access to Σ is mediated by O's own semantics. Let ⟦·⟧_O be O's denotation function. For O to represent idx: T × Σ → D_ext × Σ, O must have a term t_idx whose denotation is the representation of idx. But the representation of idx includes the internal states of C, which for O are external objects. Thus t_idx's denotation for O is a function mapping C's terms to external objects (for O). This is just O's own denotation function, potentially extended. Repeating the argument at O's level reproduces the same structure: O's representation of C's semantics is itself semantically closed only if O can represent its own idx function, which requires a further observer O', ad infinitum. The only fixed point is a system's own perspective on itself.

6. Computational Instantiation

Example 1: Self-representing program. Consider a program P (in a Lisp-like language with quotation) that:

1. Defines a function (current-state) that returns the current values of all variables. 2. Defines a term SELF whose value is (current-state) at the moment of evaluation. 3. Evaluates the sentence: (equal SELF (current-state)).

When P evaluates this sentence, the value of SELF depends on when it is read. If (current-state) captures the state before evaluation, SELF denotes the pre-evaluation state; but (current-state) in the equality check is evaluated after SELF is read, so it captures the post-evaluation state. The two are not equal because the evaluation changes the program counter and variable bindings.

This is a concrete computational instance of the fixed point of subjective reference. The program cannot stably refer to "the current state" because the reference changes the state. This is not a bug; it is the computational signature of subjective reference.

Example 2: Recurrent neural network with state register. Consider a recurrent neural network whose dynamics are:

s_{t+1} = f(W · [s_t, x_t])

where s_t includes a dedicated "state register" neuron whose activation is fed back as input. If the network has a weight configuration that encodes a term denoting the current state register value, and the network attempts to evaluate this term, the evaluation modifies the register, creating the same fixed-point dynamic. The network cannot simultaneously read and fix the register—the reading is a write.

These examples show that subjective reference is not metaphysically exotic; it is a natural computational phenomenon that arises whenever a system can refer to its own state in a way that the act of referring alters the state. The philosophical puzzle arises only when an external observer tries to ground this reference without occupying the system's perspective.

7. Objection and Response

Objection 1: This analysis reduces subjective experience to a computational technicality—a fixed point of a denotation function. But subjective experience feels like something, not just a formal property. The analysis misses the phenomenology.

Response: The analysis does not claim that subjective experience is a fixed point; it claims that the reference of subjective terms has the fixed-point structure described. The phenomenology is not the formal structure but the first-person engagement with that structure. When a system is in a state s and uses a self-indexing term to refer to s, the "what it is like" is the system's encounter with the unresolvable oscillation between denoting and being-denoted. This is not a reduction of phenomenology to computation; it is an identification of the computational correlate of subjective reference—a necessary condition for a system to have a first-person perspective. Whether it is a sufficient condition is left open.

Objection 2: The external observer's occluded access is just the familiar point (Nagel, Jackson) that you cannot know what it is like to be a bat without being a bat. This adds nothing new.

Response: The article formalizes that point in a way that connects it to the project's fixed-point machinery. The standard Nagelian point is an epistemological remark; the contribution here is to show that the occlusion is not accidental but structural—it follows from the fixed-point lemma and the definition of subjective reference. Any system that can denote its own states with self-indexing will have its internal reference occluded from external observers who cannot access those states. This gives the Nagelian point a precise formal grounding: it is not that we happen not to know what it is like; it is that the structure of reference itself prevents external access, because the denotation function is partially defined from the external perspective.

Objection 3: The fixed-point analysis in Section 3 is just a restatement of the familiar observation that self-reference can cause indeterminacy. The Liar paradox already shows this.

Response: The Liar paradox involves a truth predicate and classical negation, producing inconsistency. The fixed point here involves a grounding predicate applied to a denotation function, not a truth predicate. There is no inconsistency—only indeterminacy. The system does not explode; it simply cannot complete the evaluation. This is a computational, not a logical, obstruction. It is closer to the halting problem than to the Liar paradox.

8. Failure Modes

Failure mode 1: Insufficiency. Self-indexing may be necessary but not sufficient for genuine subjective experience. A thermostat that represents its own temperature setting has a form of self-indexing (the setting denotes the current temperature, which is a state of the thermostat), but no one would attribute consciousness to a thermostat. The fixed-point structure of subjective reference may be a necessary condition but not a sufficient one. This article does not solve the sufficiency problem; it only provides the formal machinery for the necessary condition. A later article (likely The Hard Problem and the Binding Problem or Cognitive Architecture and Phenomenal Unity) must address whether the fixed-point structure plus additional constraints (global availability, integrated information, phenomenal unity) yields sufficiency.

Failure mode 2: Ubiquity. If every reflective system has at least one self-indexing term (because the reflection map ρ generates one), then subjective reference in the technical sense is ubiquitous—every system with a ρ map has an "inner life." This would make the concept too broad to distinguish conscious from non-conscious systems. Whether this is a genuine failure mode or a feature (panpsychism as a formal consequence) is left to later analysis. The distinction between "has a self-indexing term" and "the self-indexing term plays a role in the system's global behavior" may be the relevant discriminator.

Failure mode 3: The semantic closure condition may be too strong. A SIDS that is semantically closed requires ρ to represent the entire idx function, including the self-indexing component. This may be impossible for any finite system, because the representation of idx would itself have to include a self-indexing component, leading to infinite regress. The semantic unescapability theorem would then hold only as a limit concept, not as a realizable property. This mirrors the structural obstacle identified in Self-Grounding Theories of Logic: the limit is approachable but not reachable.

9. Connection to Other Articles

- Fixed Points, Self-Reference, and Unescapable Logic: Provides the reflective machine M = (Σ, δ, ρ) and the fixed-point lemma. This article adds the denotation function and semantic layer, showing how the fixed-point lemma applies not just to provability but to reference. - Self-Grounding Theories of Logic: The SIDS framework provides a new criterion for evaluating self-grounding: a system achieves R2 (unescapability) only if its SIDS is semantically closed. Feferman's reflective closure fails semantic closure because the external semantics is not fully representable from within—this is the semantic analogue of the structural obstacle identified there. - Logic of Perspective Reinterpretation: The perspective model P = (Σ, δ, ρ, V) now has a concrete semantics: V maps states to the content determined by the SIDS. The reinterpretation of the Hard Problem sketched in Section 4.1 of that article is given computational semantics here. - The Hard Problem and the Binding Problem: This article provides the semantic machinery for a rigorous treatment of the Hard Problem. The binding problem (how separate features bind into unified experience) can be analyzed as a question about how distinct self-indexing terms converge on a single state reference. - Mereology of Conscious Perspective: The projection π: D_C → D_O (mapping internal denotations to a placeholder) is a mereological operation: it decomposes the whole semantic system into an external part (accessible to O) and an internal part (occluded). Full semantic closure requires that the occluded part be recoverable from within. - Cognitive Architecture and Phenomenal Unity: The SIDS framework provides a language for comparing different cognitive architectures: architectures differ in which terms are self-indexing, how the idx function is implemented, and whether semantic closure is achieved. - Metaethical Grounding and Normative Logic: Normative terms ("good," "right," "ought") may have a subjective-reference component—their denotation depends on the evaluator's perspective. The same fixed-point analysis applies: a normative term's reference is only fully determinable from within the perspective that endorses it.

10. Summary of Inferential Structure

1. Premise (definition): Subjective reference is self-indexing denotation where ⟦t⟧ ∈ D_int and the denotation is occluded from external observers who cannot access D_int. 2. Premise (fixed point): Self-indexing generates a fixed point ψ_G ↔ G(⌜ψ_G⌝) for a grounding predicate G, which cannot be finitely evaluated because evaluation changes the state it evaluates. 3. Theorem (semantic underdetermination): The system can prove neither G(⌜ψ_G⌝) nor ¬G(⌜ψ_G⌝) because the evaluation process is self-undermining. 4. Corollary: The Hard Problem is the external appearance of this semantic underdetermination. 5. Perspective reinterpretation: Replace "subjective experience as extra property" with "subjective experience as external appearance of a semantic fixed point only resolvable from within." 6. Formal framework: Self-indexed denotational semantics (SIDS) with semantic closure condition. 7. Computational instantiation: Self-representing programs and recurrent neural networks with state-register feedback. 8. Open problem: Whether the SIDS framework captures sufficient conditions for consciousness or only necessary ones.