Theory of Precedence

Metashifting, presentational dependence, and non-closure

Technical version

Summary

This work introduces the Theory of Precedence: the study of the relation between what appears and that which makes it possible without appearing as an object within what appears. It is not proposed as a local branch of ontology, epistemology, logic, phenomenology, or systems theory, because it cuts across all of them: every domain presupposes some condition by which its objects, rules, descriptions, and criteria can appear as such. The mother thesis is simple: every representation depends on a presentation that precedes it, and every framework operates from a precedence it cannot contain as a complete internal object.

Within that field, this work formulates metashifting as a reflexive transformation between operational frameworks. The central version of the argument distinguishes three levels that are often confused: object, representation, and presentation. By presentation we do not mean a necessarily phenomenological notion, but the relation of availability, evaluation, or execution by which an element effectively counts as a representation within a framework. The same chain of bits can be data, code, dead text, an executed program, a verified proof, or a semantic representation depending on the regime that presents it. Therefore, any non-trivial theory of representation needs something functionally equivalent to a relation of presentation if it wants to preserve the difference between token and use, syntax and semantics, code and execution, description and descriptive act.

We define a typed operational framework A through types of objects, representations, presentations, operations, criteria, interpretation, and traces. A meta-shift is a transformation A -> B in which B encodes A as an evaluable object, structurally modifies the horizon of A, and preserves, approximates, or reconstructs a relevant region of A through explicit morphisms. This replaces two overly strong theses from previous versions: that the operator mu is a single causal operation across all domains, and that each level literally contains the previous one. The defensible thesis is that there is an abstract schema Mu instantiated by heterogeneous transformations when they satisfy common formal conditions.

The main result is a thesis of non-closure. Under minimal conditions of typed non-collapse, no framework can contain as a complete internal object the current presentation by which its own internal objects are available as objects. The proof does not rest on mysticism or introspection. It rests on a minimal difference between a representation and the relation that makes it work as a representation. If one tries to capture that relation by means of a new representation, the new representation becomes available under an uncaptured current presentation. If representation and presentation are identified without remainder, one abandons the type of framework that made the problem formulable.

Version v4 adds the decisive conceptual turn: Omega is not understood as the final result of the chain, but as the precedence from which the chain can appear as a chain. Evolution, cognition, description, and self-improvement do not manufacture precedence; they locally unfold it. In that sense, evolution is a result of what precedes, not the other way around. This is not preformism: future objects are not already written as objects. What precedes is the possibility of appearance, not the inventory of what has appeared.

0. What this version solves

The original version had intuitive force, but it left several flanks open:

1. It treated mu as a single invariant operation across all domains.
2. It presupposed that each level literally contains the previous one.
3. It used Omega simultaneously as formal limit, foundation, subject/object collapse, and contemplative referent.
4. It appealed to Gödel in a structurally suggestive but insufficiently delimited way.
5. It presented the non-capture of the observer as a powerful intuition, but not as a technical result.

v2 corrected much of this, but it could still receive a strong objection:

The typing hypotheses seem chosen so that the non-capture conclusion comes out by definition.

v3 responded directly. The goal was not merely to assume that representation and presentation are distinct. The goal was to show that some distinction of this kind is unavoidable for any theory that wants to distinguish:

• token and use;
• code and execution;
• statement and truth;
• trace and reading of the trace;
• description and descriptive act;
• internal model and availability of the model;
• self-representation and foundational capture.

If that distinction is removed, the thesis is not refuted: the game is changed. One no longer obtains a more complete framework of the same type, but a collapse of the types that made it possible to speak of representation.

v4 preserves that protection and adds the name of the field: Theory of Precedence. The change is not cosmetic. "Precedence" names the central fact the formalism had been pointing to: what appears depends on a condition of appearance that is not contained in what appears. Metashifting is an operation within that field. Omega is the precedence of everything, not its limit.

0.1 The domain: Theory of Precedence

The Theory of Precedence does not fit cleanly into an already given domain because it asks about what every domain presupposes. It is not a local theory of objects. It is a theory of the relation between any appearance and what makes it possible.

Its minimal object can be formulated as follows:

what appears depends on a condition of appearance that precedes it

In the formal register of this work, that condition appears as Pres_A: the regime by which a representation counts as a representation within a framework. In the ontological register, it appears as a foundation prior to every object. In the verified register, it appears as Omega.

For this reason, the field is not defined by a particular class of objects, but by a relation:

precedence -> appearance

Metashifting is the internal operation of the field: the movement by which a horizon becomes an object of a broader horizon. Non-closure is its formal limit: no horizon contains the precedence from which it appears as a horizon. Omega is the name of absolute precedence: not the last object, not the last level, not the final product of the chain, but that from which the entire chain can appear.

Evolution is read from here in a way inverted with respect to the usual intuition. It is not that precedence emerges at the end of evolution. It is that evolution unfolds possibilities of appearance that already depend on a non-objectifiable precedence. This does not claim that organisms, concepts, or future states are preformed. It claims that the very possibility that something appear, evolve, represent itself, or be known precedes each particular appearance.

One formula summarizes the field:

Omega is not the final result of the chain.
Omega is the precedence from which the chain appears as a chain.

Notation note: in formal blocks, ASCII identifiers such as Mu and Omega are used deliberately for portability across Markdown, HTML, code, and technical copying. They are not rendering errors. In conceptual reading they correspond to the notations μ and Ω.

1. Problem

A system can improve in two ways.

It can improve internally, adjusting parameters, strategies, or search paths within a fixed horizon. In that case the states or policies of the system change, but not what counts as an object, representation, legitimate operation, or criterion of success.

Or it can improve reflexively, transforming the horizon itself into an object of analysis. In that case, what was previously framework becomes represented, evaluated, and eventually modified from another framework.

We call this second transformation a meta-shift.

The strong question is:

Can a chain of meta-shifts produce a final framework that captures its own foundation?

The word "foundation" is ambiguous. In this work we distinguish three senses:

1. Mechanical foundation: the mechanisms that causally explain the functioning of a system.
2. Formal foundation: the framework from which the system can be described as an object.
3. Presentational foundation: the current relation by which something counts as an object or representation for a framework.

The non-closure thesis refers to the third sense. It does not claim that systems cannot self-model, self-modify, access their code, register traces, simulate themselves, or prove properties about themselves. It claims something narrower:

A framework cannot turn into a complete internal object the current relation of presentation by which its own internal objects are available as objects, while preserving the difference between presented object and presentation.

The phrase "while preserving" matters. If that difference is abandoned, one does not reach a final level of the chain. One abandons the structure of the chain.

2. Why presentation is not a mystical premise

The central notion of this version is Pres_A, the type or regime of presentation of a framework A.

It may sound phenomenological. But it does not have to be read that way. There are at least three technical readings.

2.1 Semantic reading

A string of symbols does not represent by itself. It represents under an interpretation.

Example:

"101"

can mean:

• the number one hundred and one in decimal;
• the number five in binary;
• a string of characters;
• a room code;
• a signal;
• noise;
• part of a program;
• an identifier without semantics.

The token does not determine its use. A relation is needed that makes it count as a representation of something.

We call presentation that relation of interpreted availability.

2.2 Computational reading

A file with source code is not the same as an execution. The same text can be:

• stored and never executed;
• opened as text;
• parsed;
• compiled;
• interpreted;
• executed;
• treated as data by another program;
• used as a prompt;
• used as a proof;
• used as configuration.

Code is not executed merely by being code. It is executed under a regime of evaluation.

In computational reading:

presentation = evaluation / execution / current operational availability

2.3 Minimal phenomenological reading

In cognition, a content is not merely an internal causal structure. It is content for a system when it is available in some way: perceived, remembered, imagined, attended to, thought, felt, reportable, or usable.

In phenomenological reading:

presentation = appearance / givenness / experiential availability

This reading is optional for the formal core. The argument only needs the abstract reading:

A representation requires a relation by which it counts as a representation for some framework.

2.4 Minimal thesis of presentation

Thesis P. For any non-trivial framework A, there is a difference between:

r                 : an available representation
Use_A(r)           : the effective use of r as representation
Pres_A(..., r, ...) : the relation by which r becomes available as representation

Denying P amounts to saying that the token by itself determines its use, its interpretation, and its availability. That does not work in semantics, computation, or cognition.

Therefore, Pres_A is not introduced to win the argument. It is introduced because without something equivalent to Pres_A there is no theory of representation, only a theory of tokens.

3. Typed operational frameworks

We define a typed operational framework as:

A = (Obj_A, Rep_A, Pres_A, Op_A, Crit_A, Int_A, Trace_A)

where:

• Obj_A is the type of objects, states, tasks, or statements treatable by the framework.
• Rep_A is the type of representations available to the framework.
• Pres_A is the type of acts, relations, or regimes of presentation.
• Op_A is the set of admissible operations.
• Crit_A is the set of criteria of evaluation, acceptance, success, or validity.
• Int_A is an interpretation relation between representations and objects.
• Trace_A is the type of traces produced by operations of the framework.

Interpretation is written:

Int_A subset Rep_A x Obj_A

or, if the domain allows it:

Int_A : Rep_A ⇀ Obj_A

Presentation is written:

pres_A subset Pres_A x Rep_A x Obj_A

and:

pres_A(p, r, x)

means:

under the presentation regime p, the representation r is available as a representation of the object x.

3.1 Availability

We say that a representation r is available in A if there exists some p in Pres_A and some x in Obj_A such that:

pres_A(p, r, x)

Availability does not necessarily mean consciousness. It can mean:

• operational access;
• evaluability;
• successful parsing;
• current execution;
• semantic use;
• availability for inference;
• availability for report;
• availability for modification.

This notion makes it possible to unify formal, computational, and cognitive cases without reducing them to one another.

3.2 Note on "the current presentation"

A real framework can have many active or potential relations of presentation. We use expressions such as:

p_A

for notational economy. This does not mean there is a single simple entity called "the presentation". It means: the effective regime of presentation relevant for a given representation to be available at the step under consideration. If there are several regimes, the argument applies to each concrete availability:

r is available under p_i

and asks whether p_i is totally captured by r in that same act of availability.

3.3 Horizon

The horizon of a framework is:

H(A) = (Obj_A, Rep_A, Op_A, Crit_A, Int_A)

Pres_A is separated because it has a double role. From outside, it can be modeled as a component of the framework. From inside, it is the relation by which the components of the framework are available.

That double reading is the source of non-closure.

4. Internal code, model, and capture

A system can contain representations of itself. To avoid confusion we distinguish several degrees.

4.1 Encoding

A encodes x if there exists:

code_A(x) in Rep_A

This only allows reference.

4.2 Description

A describes x if code_A(x) preserves some relevant properties of x.

4.3 Model

A models x if it can use code_A(x) to infer, simulate, or explain aspects of x.

4.4 Operational self-model

A has an operational self-model if code_A(A) participates in diagnostics, predictions, or updates of the system itself.

4.5 Total capture

Total capture is much stronger. A totally captures its current presentation if there exists r in Rep_A such that:

1. r adequately models the current presentation p_A;
2. r is available to A;
3. the availability of r does not depend on any current presentation not included in r.

Condition 3 is decisive. Without it, we are talking about self-modeling, not foundational capture.

The thesis of this work does not deny 4.1-4.4. It denies 4.5 under typed non-collapse.

5. Why self-reference is not enough

Syntactic self-reference does not solve the problem of capture.

5.1 Quines

A quine can print its own code:

program -> code(program)

But the printed code appears as output under an execution. The quine does not eliminate the difference between:

produced code
execution that produces the code

If it also prints a description of the execution, that description appears under another current execution.

5.2 Interpreters and meta-interpreters

An interpreter can interpret code that describes interpreters. A meta-interpreter can interpret interpreters. But the current execution of the meta-interpreter is not exhausted by the interpreted code.

The chain:

program -> interpreter -> meta-interpreter -> ...

can grow. It does not close as an internal object without changing type.

5.3 Access to source code

A system can read its own source code. That gives it access to a representation of its structure. It does not, for that reason alone, give it total capture of the current availability of that representation.

Reading the code is an operation. The current operation of reading/evaluation is not reduced to the file read.

5.4 Key point

Self-reference produces self-referential objects. Total capture would require that the self-referential object also exhaust the current relation that makes it available as an object. That demand is stronger, and that is where the obstruction appears.

6. Meta-shift

A transformation:

mu : A -> B

is a meta-shift if it satisfies four conditions.

M1. Reflexivity

B contains an evaluable encoding of A, or of an adequate model of A:

code_B(A) in Rep_B

M2. Structural novelty

The horizon changes in a way not reducible to parametric adjustment:

H(A) != H(B)

That is, at least one of the following changes:

Obj, Rep, Op, Crit, Int

M3. Declared conservation

There exists a conservation relation:

tau : A ⇀ B

defined over a relevant region K_A.

M4. Evaluation of the previous framework

B can evaluate some limit, failure, extension, or condition of validity of A:

Eval_B(code_B(A)) is defined

Without M4 there is only representation of the previous framework, not a meta-shift in the strong sense.

7. Conservation through morphisms

The literal inclusion:

A subset B

only works in some cases. In general we need partial morphisms:

tau = (tau_Obj, tau_Rep, tau_Op, tau_Crit, tau_Int)

with:

tau_Obj  : Obj_A ⇀ Obj_B
tau_Rep  : Rep_A ⇀ Rep_B
tau_Op   : Op_A ⇀ Op_B
tau_Crit : Crit_A ⇀ Crit_B
tau_Int  : Int_A ⇀ Int_B

7.1 Exact conservation

For r in K_A:

Crit_A(r) = Crit_B(tau_Rep(r))

and:

Int_B(tau_Rep(r)) = tau_Obj(Int_A(r))

7.2 Approximate conservation

There exists a distance d such that:

d(Int_B(tau_Rep(r)), tau_Obj(Int_A(r))) <= epsilon

7.3 Reconstructive conservation

B does not preserve A as true, but it can explain:

• why A worked locally;
• under what idealizations it was useful;
• why it failed outside a certain regime;
• what assumptions made it possible.

This notion prevents the paper from depending on a naive history in which every later framework cleanly contains the previous one.

8. Invariance of Mu

There is no single causal operation that explains mathematics, physics, motor learning, generative systems, and contemplative cognition in the same way.

The defensible strong thesis is:

mu_i instantiates Mu

when mu_i satisfies M1-M4.

The invariance is schematic:

operative horizon -> evaluable object within a transformed horizon

It is not causal, psychological, or physical identity.

9. Types of meta-shift

9.1 Extensive

mu_ext occurs when the framework fails because it lacks the appropriate type, domain, or representation.

Signature:

undefined
no value
operational silence

9.2 Resolutive

mu_res occurs when the framework produces evaluable answers that are systematically false, unstable, or incoherent.

Signature:

error
refutation
failed prediction
defective criterion

9.3 Mixed

mu_mix occurs when an expansion of domain simultaneously reveals that prior criteria require reconstruction.

Signature:

initial silence + revision of criteria

10. Reflexive chains

A conservative reflexive chain is:

A_0 --tau_0--> A_1 --tau_1--> A_2 --tau_2--> ...

where:

A_{n+1} = mu_n(A_n)

and each tau_n declares the mode of conservation.

The chain is strict if:

A_n <_{tau_n} A_{n+1}

that is, if A_{n+1} is not a mere recoding of A_n.

Sufficient conditions of strictness:

• new objects;
• new representations;
• new operations;
• new criteria;
• new interpretation;
• evaluable model of A_n nonexistent in A_n;
• diagnosis of a limit that A_n could not formulate.

11. Generative meta-systems

For generative systems:

A_n = (D_n, G_n, L_n, E_n, I_n)

where:

• D_n is the domain of tasks;
• G_n generates candidates;
• L_n filters or aligns;
• E_n evaluates;
• I_n interprets outputs.

The system induces:

P_n(y | x)

An associated meta-system is:

M_n = (Obs_n, Q_n, F_n, H_n, Prop_n, U_n)

where:

• Obs_n records traces;
• Q_n transforms traces into metrics;
• F_n detects failures;
• H_n attributes causes;
• Prop_n proposes modifications;
• U_n validates or applies modifications.

The loop:

Obs_n -> Q_n -> F_n -> H_n -> Prop_n -> U_n -> A_{n+1}

is a meta-shift only if it can modify the horizon, not only parameters.

12. Domain orientation and subject orientation

12.1 Domain orientation

Mu_D takes as object:

• tasks;
• data;
• theories;
• models;
• criteria;
• operations;
• traces;
• policies;
• architectures.

It produces more reach or control over objects.

12.2 Subject orientation

Mu_S takes as object the pole or relation by which something appears as object.

Formally, if p_A in Pres_A is the current presentation of A, then B can contain:

code_B(p_A) in Rep_B

But that encoding is available in B under some current presentation:

p_B in Pres_B

Therefore:

p_A -> code_B(p_A) -> p_B

The problem does not disappear. It shifts.

13. Minimal hypotheses of non-collapse

We work with frameworks that satisfy:

H1. Representational objecthood

Every r in Rep_A is available as a representational object within A.

H2. Dependence of availability

If r is available as a representation in A, then there exists some p in Pres_A such that p presents r as a representation.

H3. Type/use difference

No representational token determines by itself its total use. Use depends on a regime of presentation, interpretation, or evaluation.

H4. Non-collapse

As long as A remains a typed operational framework, it does not identify without remainder:

Rep_A = Pres_A

nor:

r = p_A

for a representational object r and the current presentation that makes it available.

H5. Possible internalization

A framework can encode previous presentations or aspects of its own architecture:

code_A(p_previous) in Rep_A

This prevents the theory from trivially prohibiting reflection.

H1-H5 are the core. The first four block collapse; the fifth allows real self-modeling.

Scope note. The results of section 14 are immediate consequences once H1-H4 are accepted. They are not presented as the mathematically strong part of the work, but as the formal unpacking of the minimal hypotheses of non-collapse. The substantive content comes before and after: in the justification that something like Pres_A is unavoidable for distinguishing token and use, developed in section 2, and in Conjecture D of section 24, where the still-pending diagonal program is located.

14. Non-capture

14.1 Total capture

A totally captures its current presentation p_A if there exists r in Rep_A such that:

1. r adequately represents p_A;
2. r is available to A;
3. the availability of r does not depend on any current presentation not contained in r;
4. A can internally evaluate that 1-3 are satisfied.

Condition 4 prevents a merely external capture: it is not enough for an external observer to say that r captures p_A.

14.2 Dependence lemma

Lemma 1. Under H1-H4, if r in Rep_A is available to A, then its availability depends on some presentation p in Pres_A that is not identical without remainder to r.

Proof. By H2, the availability of r requires some presentation p. By H3, the token r does not determine by itself its total use. By H4, r and p are not identified without remainder within a typed framework. Therefore, the availability of r depends on a presentation not exhausted by r. □

14.3 Non-capture lemma

Lemma 2. Under H1-H4, no typed operational framework totally captures its current presentation.

Proof. Suppose A totally captures p_A by means of r in Rep_A. By condition 2 of capture, r is available to A. By Lemma 1, the availability of r depends on a presentation p not exhausted by r. If p = p_A, then r does not exhaust the presentation it was supposed to capture. If p != p_A, then the availability of r depends on another effective presentation not contained in r. In both cases condition 3 of total capture fails. Contradiction. □

The force of the lemma rests on H2-H4 being substantive: the conceptual work lies in justifying the inevitability of Pres_A, and the strong mathematical work is located in Conjecture D of section 24.

14.4 Corollary of displacement

Corollary 1. If B encodes the presentation of A, then the current presentation of B remains uncaptured by that encoding.

Proof. code_B(p_A) can be an adequate representation of p_A. But in order to be available in B, it depends on some presentation p_B. By Lemma 2, p_B is not totally captured in B. □

14.5 Theorem of reflexive non-closure

Theorem 1. Let:

A_0 -> A_1 -> A_2 -> ...

be a reflexive chain in which each A_{n+1} encodes some aspect of the presentation of A_n, and each A_n satisfies H1-H5. Then no A_n totally captures its own current presentation.

Proof. For any n, Lemma 2 applies to A_n. If A_{n+1} encodes p_{A_n}, Corollary 1 displaces non-capture to p_{A_{n+1}}. By induction, each step can objectify a previous presentation, but not the current presentation of the framework that performs the objectification. □

14.6 Theorem of no final framework

A framework F would be a final typed closure if:

1. all A_n are preserved, approximated, or reconstructed in F;
2. F contains evaluable models of the A_n;
3. F contains an evaluable model of its own operation;
4. F satisfies H1-H5;
5. F totally captures its current presentation.

Theorem 2. No final typed closure exists.

Proof. If F satisfies H1-H5, then in particular it satisfies H1-H4. By Lemma 2, F does not totally capture its current presentation. This contradicts condition 5. □

14.7 Strong trichotomy

Faced with subject orientation, a framework has only three exits:

1. Regress: it encodes the previous presentation and generates a new current presentation.
2. Externalization: it appeals to an external framework that represents it, displacing the problem to that framework.
3. Collapse: it abandons the distinction between representation and presentation.

The first produces a tower. The second produces meta-theory. The third abandons the schema.

15. The colimit and Omega

15.1 Formal limit

Given a chain:

A_0 --tau_0--> A_1 --tau_1--> A_2 --tau_2--> ...

we can construct:

colim_n A_n

This means that we gather the information of the chain by identifying each framework with its image under the conservation morphisms.

colim A_n is a formal object. It can be useful, legitimate, and mathematically precise.

15.2 Why it does not close

If some framework B represents colim A_n, then:

code_B(colim A_n) in Rep_B

But that representation is available under some presentation p_B.

By Lemma 2, B does not totally capture p_B.

Therefore, colim A_n is not foundational closure. It is a formal limit.

15.3 Omega: precedence

Omega is not the roof of the chain. colim A_n is the roof of the chain, a formal object that the chain reaches from above. Omega is on the other side: it is the precedence from which the entire chain, and its colimit, can appear as a chain. One does not reach Omega by climbing. Omega is already before any floor.

For that reason, within the formalism it can only be named negatively:

Omega = that which cannot be captured as object without abandoning the object/presentation distinction

It is not an additional object of the theory. It is the name of precedence, and precedence is not an object.

Therefore:

Omega != colim A_n
Omega notin {A_n}

The colimit points toward Omega from inside the chain, but it is not Omega. The formalism constructs colim A_n and thereby points. Pointing is not containing. That Omega is, beyond the name of precedence, a directly recognized referent is the extra-formal thesis of section 23.4. It does not belong to the formal core, not because of weakness but for the same structural reason: Omega is precisely what no representation captures.

15.4 OAC: reading note, not a new formal operator

We call OAC the operator of access to the colimit, but the name must be read carefully. In the formal register it does not introduce a construction distinct from the colimit and does not add independent probative force. It is only an abbreviation for considering a conservative reflexive chain from the formal limit already constructed.

Formally, given the chain:

A_0 --tau_0--> A_1 --tau_1--> A_2 --tau_2--> ...

the abbreviation says:

OAC(A_0, A_1, A_2, ...) = colim A_n

This line does not name a substantive new mathematical operator. It names the standard act of passing from the chain to its constructed colimit. Therefore, if OAC is retained, it must be understood as a notation of reading, not as an additional formal piece.

The proper content of OAC lies in the presentational reading: it does not produce Omega, it does not gradually approach Omega, and it does not add a new level. It reorients attention from the series of levels toward what the series presupposes in order to appear as a series.

In that sense, OAC is not a proof. It is the technical gesture that marks where reading by levels stops being interpretable as the production of its own foundation:

climbing levels -> recognizing the precedence of the limit

The colimit remains colim A_n. OAC only names the relation of reading by which that colimit stops being confused with foundational closure.

16. Formal instantiation I: naturals to integers

Initial framework:

A_N = (Obj_N, Rep_N, Pres_N, Op_N, Crit_N, Int_N, Trace_N)

where:

Obj_N = N
Op_N includes +, *
Op_N includes partial subtraction only when a >= b

The expression:

4 - 6

generates operational silence:

sub_N(4, 6) undefined

Later framework:

A_Z = (Obj_Z, Rep_Z, Pres_Z, Op_Z, Crit_Z, Int_Z, Trace_Z)

with:

Obj_Z = Z
sub_Z total

Morphism:

tau_Obj : N -> Z
tau_Obj(n) = n

Conservation:

forall a,b in N: add_Z(tau(a), tau(b)) = tau(add_N(a,b))

Type:

mu_ext

Here the previous framework survives as a substructure. This is the clean case.

17. Formal instantiation II: empirical theory and reconstruction

Let A_old be an empirical theory with:

Pred_old : Conditions -> Observables
Crit_old = match within tolerance epsilon

A set E appears such that:

exists e in E : d(Pred_old(e), Obs(e)) > epsilon

A framework A_new introduces new representations, criteria, or latent variables:

Rep_old -> Rep_new
Crit_old -> Crit_new
Int_old -> Int_new

Conservation is not literal. It is approximate or reconstructive:

for x in K_old:
d(Pred_new(tau(x)), Pred_old(x)) <= epsilon

or:

A_new explains why A_old works in K_old and fails outside K_old

Type:

mu_res or mu_mix

This example shows why subset was too weak as a theory of change. The correct notion is tau.

18. Formal instantiation III: quine

Let Q be a program such that:

Exec(Q) = code(Q)

This proves that syntactic self-reference exists.

But in our formalism:

code(Q) in Rep_A

and its availability depends on:

Exec_A

which functions as computational presentation.

The quine produces:

code(Q)

It does not produce:

total_capture(Exec_A)

If Q also prints a description of Exec_A, that description appears again under Exec_A or under another regime of execution.

Type:

syntactic self-representation, not foundational meta-shift

19. Formal instantiation IV: self-improving generative system

Let:

A_n = (D_n, G_n, L_n, E_n, I_n)

with distribution:

P_n(y | x)

Meta-system:

M_n = (Obs_n, Q_n, F_n, H_n, Prop_n, U_n)

Suppose F_n detects:

failure cluster C

and H_n attributes:

cause(C) = evaluator misspecification

Prop_n proposes:

E_n -> E_{n+1}

If the update changes criteria:

Crit_n != Crit_{n+1}

then there is a meta-shift.

But if the system tries to capture its own current presentation:

code_{A_{n+1}}(p_{A_n})

that encoding is available under:

p_{A_{n+1}}

By Lemma 2, there is no total capture.

Conclusion:

technical self-improvement yes
foundational closure no

20. Formal instantiation V: reflexive cognition

Sequence:

content -> thought about content -> observation of thought -> observation of the observer

Each step turns something into an object:

x_n -> code_{n+1}(x_n)

But each code_{n+1}(x_n) appears under a current presentation:

p_{n+1}

The "witness" can be modeled as stabilization of an observing pole:

witness_A ~ p_A as attended pole

But if it is taken as an object:

code_B(witness_A)

it appears under p_B.

Therefore, the witness is threshold, not closure.

This section does not prove contemplative doctrine. It only formalizes why "observe the observer" produces silence, displacement, or collapse when an object is sought.

21. Relation to Gödel, Tarski, Lawvere, and reflection

21.1 Gödel

The relation to Gödel is structural:

sufficient reflexivity -> self-reference -> internal non-closure

We do not claim that every framework is an arithmetical formal system.

21.2 Tarski

The analogy with Tarski is closer:

total internal truth blocked
total internal presentation blocked

But turning this into a Tarskian theorem would require formalizing an internal predicate of presentation and conditions analogous to the T-schema.

21.3 Lawvere

Categorical diagonal theorems show that many forms of self-reference produce fixed points or limits when there is sufficient capacity for internal representation. A future path is to construct a category of frameworks and study whether a final reflexive object generates contradiction, triviality, or collapse of types.

21.4 Kleene and recursion

Recursion theorems show that programs can obtain descriptions of themselves in a syntactic sense. This strengthens, rather than weakens, the distinction: syntactic self-description is possible; total presentational capture does not follow.

21.5 Second-order cybernetics

Second-order cybernetics places the observer inside the observed system. Metashifting adds a distinction: including models of the observer does not capture the current presentation that makes those models available.

21.6 Enactivism and autopoiesis

Enactive and autopoietic theories insist that cognition is not mere passive representation, but constitutive activity. This is compatible with Pres_A: presentation can be read as enactive availability, not as an internal screen.

22. Objections

Objection 1: "The conclusion is in the premises."

Response: the difference between representation and presentation is not arbitrarily stipulated. It is justified by the need to distinguish token and use. Without that difference, there is no semantics or execution, only inert objects.

Objection 2: "A system can have access to all its code."

Response: access to code is not capture of the current execution that makes that access available.

Objection 3: "A quine represents itself."

Response: it represents itself syntactically. The thesis blocks total presentational capture, not syntactic self-reference.

Objection 4: "A transfinite limit could close the chain."

Response: it can close a formal construction. If that limit is represented by a framework, the presentation of the framework reappears. If it is not represented by a framework, it is not an operational level of the chain.

Objection 5: "It is enough to identify representation and presentation."

Response: that is collapse, not meta-shift. It can be a philosophical position, but it abandons H1-H4 and with them the theory of typed frameworks.

Objection 6: "This denies reflection."

Response: on the contrary. The theory allows arbitrarily rich reflection. It only denies total closure under non-collapse.

Objection 7: "Presentation remains obscure."

Response: in v4 it has three readings: semantic, computational, and phenomenological. The argument uses only the abstract reading of availability under a regime of use.

23. Consequences

23.1 For self-improving systems

A system can:

• observe itself;
• evaluate itself;
• diagnose failures;
• propose modifications;
• modify criteria;
• modify architecture;
• modify parts of its meta-system;
• build operational self-models.

None of this implies total capture of its current presentation.

23.2 For theory of cognition

A cognitive theory that models only contents leaves out the availability of contents. A theory that turns that availability into content displaces the problem to the availability of the new content.

23.3 For theory of descriptions

Every description presupposes a regime under which it counts as a description. A meta-description can describe previous descriptions, but it cannot exhaust as an internal object the current presentation that makes it available.

23.4 Extra-formal declaration on direct verification

The formalism does not demonstrate direct verification. It demonstrates the wall: that no framework totally captures its current presentation. What lies on the other side of the wall is not the object of this work, and cannot be. What it does establish, and this is not little, is formal precedence: every representation depends on a presentation that is not contained in it.

It is useful to separate three senses of "precedence":

1. Formal precedence: every representation depends on a regime of presentation. This is what the paper argues within the formalism.
2. Ontological precedence: the foundation is prior to every object and every framework. This the paper marks as a frontier, not as a theorem it proves.
3. Verified precedence: Omega was directly recognized. This belongs to de-oblivion, not to the representational apparatus of the paper.

Omega

appears here, for the formalism, as a negative frontier. In the register of the Theory of Precedence, Omega is the precedence of everything: not a first entity, not a cause among causes, not a maximum object, but that from which object, cause, framework, time, evolution, and description can appear.

But there is an additional thesis, declared here and developed separately: that frontier admits direct verification. It is not a hypothesis awaiting intersubjective confirmation. It is knowledge not linguistically transferable, and for that reason it remains outside this paper, not out of caution but by structural necessity. The very result of non-capture (Lemma 2) requires this: verification belongs to the domain that representation cannot capture, and a paper is representation. Trying to house it in the formalism would be the attempt at total capture that Theorem 1 prohibits.

Whoever has the verification recognizes the frontier from within. Whoever does not remains with the wall, which is already a complete result.

24. The mathematical version: one diagonal, four routes to build

Previous versions left this section as four programs to be done. An intermediate version went to the opposite extreme and presented it as closed. Neither position is correct. The honest position is the middle one: the core wants to be a diagonal argument, the intuition is strong and probably correct, but it is not yet demonstrated. What this section does is locate the program precisely. It states the conjecture, identifies the schema, and names by route the exact lemma that is missing. Locating is not closing. But a precisely located program is much harder to attack than a claim of closure that does not hold.

24.0 The diagonal conjecture

Cantor, Russell, Gödel, Tarski, and the halting problem are, in the reading of Lawvere and Yanofsky, one and the same diagonal argument. The schema, in a structure with sufficient self-application, is:

alpha : Rep x Rep -> Out
total capture  <=>  alpha is point-surjective onto [Rep, Out]
g : Out -> Out without fixed point
d(r) := g(alpha(r, r))
if alpha is surjective  =>  there exists r* with alpha(r*, -) = d
                         =>  alpha(r*, r*) = g(alpha(r*, r*))  =>  g has a fixed point. Contradiction.

Conjecture D. The non-capture result (Lemma 2) is an instance of this schema, and the four routes below are its faces in four substrates.

What the conjecture needs in order to become a theorem is precise, and it should not be hidden. The diagonal bites only if two things hold that H4 by itself does not provide:

(i)  the exponential object [Rep, Out] exists, or the equivalent cartesian
     closed structure exists
(ii) there exists g : Out -> Out constructed from the axioms of non-collapse,
     and it is proved to have no fixed point

H4 says "do not identify r with p_A". That is a restriction on the framework, not the construction of a fixed-point-free map. The intuition is that regress, every attempt to fix the current presentation producing a new current presentation, is that g, and that a fixed point of it would be a presentation identical to its complete representation, which H4 forbids. But moving from "H4 forbids that coincidence" to "this concrete endomorphism has no fixed point" requires defining g, defining what its fixed point would be, and deriving the violation. That is the crux of the entire program, and it remains pending.

24.1 Type theory

The total capture of Pres_A by Rep_A in the same universe has the form of Type : Type: it internalizes the universe of presentations as an object of the universe of representations. Girard's paradox establishes that Type : Type is inconsistent, and H4 is the stratification that blocks it.

This is a strong analogy, not a reduction. To turn it into a reduction one would have to construct the universes, the formation, introduction, elimination, and reduction rules, and derive the inconsistency within those rules. Pending: that construction. Until it exists, the correct claim is "it has the form of Type : Type", not "it is Type : Type".

24.2 Categories

This is the route where the crux of 24.0 lives. One would construct a category Frame (objects: typed frameworks; morphisms: conservations tau; endofunctor: reflection). The colimit colim A_n exists. A terminal reflexive object would be a framework that captures its own presentation, and that would be a point-surjection whose non-existence would follow from Lawvere, provided the exponential of (i) and the fixed-point-free g of (ii) exist.

What remains pending is exactly (i) and (ii): that the relevant fragment be cartesian closed, and that g be constructed and proved fixed-point-free from non-collapse. If both are achieved, the clean result follows: the colimit exists but there is no final reflexive object, which is the formal content of "the tower has a limit and the limit does not close it". For now this is a conditional implication, not a theorem.

24.3 Logic

One would expect a Tarski-type obstruction. A language L_Frame with predicates Rep, Pres, Avail, Captures, with sufficient self-coding (H5) for the diagonal lemma, and an internal predicate Captures adequate for the current presentation, should produce:

delta  <->  not Captures( code(delta), p* )

and from there contradiction, leaving Captures internally undefinable as an adequate total predicate. This is Tarski's undefinability in a presentational key.

Pending: define L_Frame, the predicate Captures, the presentational T-schema, and verify that the diagonal lemma applies. Until then, this is a program with a clear theorem-target, not a theorem.

24.4 Computation

This is the route closest to being formalizable and the best bridge to AI, but the thesis must be formulated precisely, because in raw form it is false. Continuations, reflection, self-interpreters, debuggers, snapshots, and virtual machines exist. A system can represent enormous portions of its own execution. The correct thesis is not "no program represents its execution". It is:

no reification eliminates dependence on a current evaluator context
not contained in that reification

reify(e) = rep(e) is produced by an execution e' whose context is not in rep(e). The reflexive tower, the towers of interpreters, are unbounded for this reason. Kleene's recursion theorem sharpens the thesis rather than refuting it: a program obtains its own source code, real syntactic self-reference, but code(p) is syntax, not the activation that is reading it right now.

The bridge to AI is direct and survives the correction. An arbitrarily reflexive self-improving system reifies any previous layer of its operation, but not the layer that is doing the reifying, because that is the execution in progress. The ceiling of autonomy is the residual dependence on the current evaluator context, not an impossibility of self-representation in the raw sense.

24.5 What is located, and what remains pending

The four routes converge because the conjecture is that they are one and the same diagonal in four substrates. That convergence is the strength of the program: to break the result one would have to kill self-coding (H5, and reflection is lost) or collapse the types (H4, and one no longer has a framework). There is no third exit, which is the trichotomy of 14.7 read from the other side.

What is located, not closed: the obstruction is not a vague intuition, but a precise conjecture with a missing lemma named by route. The crux is the fixed-point-free g of the categorical route, with the existence of the exponential as its precondition. The routes of types, logic, and computation each have an explicit theorem-target and a pending construction.

The pending burden, said without ornament, is to build each reduction without changing the types. That is conceptual work, not merely mechanical work, especially in the categorical route. It is not sold as fact. It is left as the exact program.

And one last precision, because it orders everything above. The work of the formalism here is not to reach what precedes. It is to locate the obstruction with enough precision for the precedence it indicates to become undeniable: every representation depends on a presentation that does not contain it. Recognizing that precedence is another act, and it lives outside this paper for the same structural reason as 23.4. The formalism carries one to the wall with all possible rigor. What the wall precedes is not demonstrated; it is recognized.

25. Conclusion

The Theory of Precedence does not study an object among objects. It studies the relation by which any object, framework, description, or evolution appears from something that precedes it.

Metashifting is not simply learning more. It is turning an operative horizon into an object of a transformed horizon. For that reason it is a central operation of the Theory of Precedence: it shows how a framework can objectify its own horizon, and it also shows the limit of that objectification.

The unity of Mu is not causal but formal:

horizon -> evaluable object within another horizon

The chain of meta-shifts can grow indefinitely. It can produce broader theories, better models, self-improving systems, and sophisticated meta-systems. It can have formal limits such as colim A_n. Considering the chain from that colimit, the gesture named above as OAC in a presentational sense, neither manufactures nor contains precedence. It only points to it from the register of the chain.

But when the operation is oriented toward the subject, technically understood as the current presentation that makes objects available, the obstruction appears:

every representation of presentation appears under a presentation

The previous presentation can be objectified. The current one is not exhausted by that objectification.

For that reason, there is no final typed framework. There is regress, externalization, or collapse. The tower can describe more and more of itself, even its impossibility of closure. But as long as it remains a tower, its closure is not another floor.

Evolution, cognition, and self-improvement do not produce precedence. They are local unfoldings of possibilities that depend on it. Omega names the precedence of everything: not the end of evolution, but that from which evolution, the chain, time, and knowing can appear.

The final formula is:

what appears does not found precedence;
precedence founds the possibility of appearance.