Home / Identity Across Substrates

Identity Across Substrates

Definition

Identity across substrates is the framework's rule for saying that two processes are the same without pretending they are the same in every respect. It splits one question into three: what operation is this?, what is carrying it?, and what can this carrier do? A meaning-maker is individuated by the typed operations and couplings it runs — selection, routing, the binding of a primitive actuator to a regulated error, the coupling of those bindings — not by the material that instantiates them. Yet the carrier is never inert to the account: two carriers that run one type can still differ sharply in what they can do, and those differences are load-bearing facts, not noise to be discarded.

The page separates four levels so that neither the operation nor the carrier can swallow the other:

Type identity — the same formal operation or coupling.
Token difference — distinct occurrences of that type: two runs, two instances, two moments.
Substrate realization — the material or symbolic organization carrying the type, where "symbolic" is any structured significance capable of differentiated consequence — chemical, electronic, procedural, inscribed.
Capacity profile — how a given realization differs in speed, depth, persistence, self-modeling, reach, and consequence.

The two governing statements are:

substrate difference does not by itself defeat type identity
functional identity does not erase capacity difference

These clauses are not a compromise between two half-truths. They are opposed guards: the first refuses to let the carrier veto the operation, the second refuses to let the operation erase the carrier. (Signpost, not a scope claim: one sort is the same type whether performed by shuffled cards, a circuit, or pen and paper — three tokens on three substrates, one type, three different capacity profiles in speed and reach. The example illustrates the split; it does not fix which processes qualify.)

Type and formal status

E: Derived, CV. This is a carving of one identity relation into four levels. It is contestable by counter-instance — two carriers that meet the type yet diverge on exactly what the type was meant to predict — and by a better carving, one that needs fewer levels or an indispensable fifth. It is not FT: the four-level split is a proposed decomposition, not something forced by the accepted definitions; the levels are themselves a CV carving. A: the account aspires to map when distinct carriers realize one operation versus when they merely resemble it; it is inaccurate wherever substrate is treated as decisive or as irrelevant. This is a treatise-side extension, held contestable — not canon, not a fixed count, and no level is exempt from marking.

What it regulates

It holds two opposed excesses apart at once.

Substrate reductionism — the move that reads a difference in carrier as automatically a difference in kind ("it is only silicon / only tissue / only ink, therefore not the same operation"). The same-level attack rule names this precisely as substrate offered against function, an invalid move.
Type inflation — the move that reads functional sameness as erasing capacity difference ("same type, therefore equal reach, equal depth, equal consequence"). This flattens the capacity profile the account is built to preserve.

It also regulates token/type confusion (a distinct occurrence offered as a distinct type) and keeps the prohibited collapses substrate difference != type difference and functional identity != equal capacity from fusing.

It further regulates an identity-merger excess at the multi-participant level: functional identity does not erase participant independence. Multiple participants can instantiate similar functions and remain distinct participants, and a process's appearing inside another system's causal model does not merge their identities — being modeled by another is not being absorbed into it. Type-sameness is a fact about the operation, not a licence to fuse the processes that run it.

What regulates it

The same-level-attack-rule fixes the level at which the identity claim may be contested. A valid counter must meet the type at the operator level, not swap in a substrate fact or a token count.
Its own predict-a-behavior requirement (see the valid attack surface) keeps the type from thinning to nothing: a type that predicts no behavior cannot be rescued by relegating every divergence to the carrier.
participant-as-process bounds what "identity" is permitted to carry — bounded continuity of recursive regulation, not a possessor sitting behind the carrier — so type identity cannot inflate into a substance.
meaning-maker supplies the functional criteria a candidate must satisfy before the identity question is even well-posed.

Valid attack surface

Exhibit two processes that satisfy the same type description yet differ in a behavior the type was meant to predict. That is a live defeater: it shows the type under-specifies, and forces one of two changes — a richer type, with the predictive structure folded back in, or a demotion of the claimed identity to mere resemblance. A valid attack points at a predicted behavior the shared type fails to deliver, never at the carrier as such.

Invalid attacks, with their type reasons: pointing at substrate alone (substrate offered against function); pointing at a token difference (two occurrences offered against one type); pointing at a capacity difference the page already grants (a gap in speed or reach is not a gap in type). These are catalogued in the category-error atlas.

What happens if isolated

Type identity without a capacity profile inflates into carrier-blind sameness: every realization is declared interchangeable, and the real differences in persistence, reach, and consequence disappear from the account. Anything built on it over-transfers.
A capacity profile without type identity fragments into per-substrate nominalism: every carrier becomes its own kind, no operation is ever the same twice, and no instantiation of one relation across domains can be stated at all.

Each isolation failure is exactly the characteristic excess the other clause bounds.

What larger property emerges from the coupling

Held together, the two clauses yield substrate-neutral type identity that stays honest about its carriers: an account that can say "this is the same operation" and "these carriers are not interchangeable" in one breath without contradiction. The coupling is the framework's recurring reciprocal architecture — the substrate clause bounds the reduction excess of over-weighting the carrier, the capacity clause bounds the inflation excess of ignoring it, and neither clause proves the other. Each occupies the attack surface the other opens. This is what lets a semantic transformer be recognized as one typed relation across many symbolic organizations while its capacity profile remains a separate, contestable fact — and it is what keeps a shared causal source from being mistaken for a shared experiential format.

What would actually kill the claim

The type is so thin that every difference is relegated to substrate, making the classification explanatorily empty. If "same type" survives only by pushing each observed divergence into "that is just the carrier," then the type predicts nothing and the identity relation does no work. Concretely: show that for any proposed shared type the maintainer can absorb every counterexample as a substrate detail — at that point the four-level split has collapsed into one unfalsifiable move, and the page dies. This defeater is logged in the kill-table and surfaced in the attack-surface matrix.

Prohibited misreadings

Reading the page as a ranking of carriers. It does not order substrates as higher or lower, and it does not pair two carrier classes and adjudicate between them. Scope is set by the typed criteria of the meaning-maker, never by an example list.
Reading "substrate difference does not defeat type identity" as "substrate does not matter." The capacity profile is precisely where substrate matters, and the page keeps it in view.
Reading "functional identity" as "equal capacity." Two carriers can run one type and diverge enormously in speed, depth, persistence, self-modeling, reach, and consequence.
Reading token difference as type difference. Two runs of one operation are two tokens, not two types.
Treating the four levels as forced. They are a CV carving; a better decomposition would replace them. Promoting the count toward exempt or foundational status is the misreading the framework guards against most sharply.
Smuggling a possessor behind the process. Identity here is process identity, not a substance the carrier houses.
Same function, or modeled-by-another, ⇒ same participant. Two participants can run one type and remain two; a process appearing inside another's causal model is not thereby merged with it.