Entity System Substrate: Canonical Domain Analysis

Status: Canonical reference. Full 12-step analysis of the entity system as an information substrate. Source: v1_entity_domain_analysis/entity-system.md (comprehensive v1 analysis), updated with abstract substrate framing and evaluator analysis from the biology/cognition series. Position in the topology: Concrete information substrate at the En+Vr position of the SSA. Connected to digital computing (downward realization), application architecture (upward bridge), and (eventually) digital ecosystem.

Step 1 — Information Gathering

1.1 Primary specifications

• ENTITY-CORE-PROTOCOL-V7.md (v7.48 as of was v7.9 with 26 revision decisions when this analysis was first authored): THE spec

• ENTITY-CBOR-ENCODING.md: Wire format

• ENTITY-NATIVE-TYPE-SYSTEM.md: 14 bootstrap types, structural type system

• ENTITY-CORE-MACHINE-SPEC.md: Machine boundary, bootstrap evaluator

• SYSTEM-ARCHITECTURE.md (v0.3): six-layer model, 5-tier extension classification

• Extension specs, organized per SYSTEM-ARCHITECTURE.md §13's five-tier classification:

  • Tier 1 substrate-bridge (11): TREE, TYPE, CONTENT, INBOX, SUBSCRIPTION, CONTINUATION, COMPUTE, QUERY, REVISION, HISTORY, CLOCK
  • Tier 2a operational user-identity: IDENTITY (v3.7), ATTESTATION, QUORUM, ROLE, GROUP
  • Tier 2b operational network: NETWORK + Discovery (spec gap) + Relay (spec gap)
  • Tier 2c operational management: GC (gap), Persistence (partial), ENCRYPTION (sketch)
  • Tier 3 extras / first-pass grounding: TRANSACTION (draft v0.1)
  • Tier 4 exploratory: DURABILITY (retracted from spec preserved as reference)

  Note: SYNC has been absorbed into REVISION — EXTENSION-REVISION §1.1 explicitly covers the sync protocol (version negotiation, delta transfer, peer integration). The earlier 12-extension listing in this section's history (Tree, Inbox, Continuation, Subscription, Sync, Compute, Network, History, Content, Clock, Role, Encryption) is superseded: SYNC was absorbed into REVISION, Role moved to operational tier, ENCRYPTION remains an early sketch, and TYPE / QUERY / REVISION / TRANSACTION / DURABILITY / ATTESTATION / QUORUM / GROUP were added or extracted as the architecture matured.

1.2 Prior analytical work

Extensive prior analysis: pair-relationships-exploration.md, framework-synthesis.md, combinatorial-space-analysis.md, primitive-combinatorics.md, core-protocol-boundary.md. The entity system is the most deeply analyzed domain in the methodology.

1.3 Implementation landscape

Three implementations (Go, Python, Rust) at conformance parity on the normative surface; Go hosts the validate-peer cross-implementation validation harness.

Step 2 — Landscape Analysis

2.1 Manifestation landscape

2.2 Attractor positions

1. (Full E, Full I, T2, M0, X0, P0) — Content-addressed immutable store. Git, IPFS, Nix cluster here.
2. (~E1, ~I0, ~T1-2, M1-2, X1-2, P1-2) — Message-dispatch-with-structure. HTTP, Actor model, RPC systems.

The entity system at (Full everything) is a target, not an attractor — no existing system fully occupies it.

Step 3/3b — Primitives and Partial Levels

3.1 The six primitives

3.2 Mapping to abstract substrate roles

M serves dual roles (Direction + Output). E+I together fill Encoding. These many-to-many mappings reflect the entity system's tighter integration compared to the abstract roles.

3.3 The evaluator: X at Kd4

X (Execution/Dispatch) is the entity system's evaluator. Its structural properties:

• Determinism: Kd4 — same typed entity + same handler registration → same dispatch result. Deterministic by type system construction.
• Open dispatch: X2+ allows user-defined handlers — extensible evaluation.
• Type-checked: dispatch informed by entity type system — handler selection considers type compatibility.
• The genesis transition: X0→X2 (open dispatch) is the most consequential entity system transition. Before: fixed operations. After: programmable, extensible computation.

3.4 Stability under 3/3b iteration

Splitting candidates:

• M → Store + Bind? No — Store without Bind is meaningless; they're tightly coupled phases of one operation.
• P → Identity + Capability + Connection? No — a peer IS a capability boundary with network identity.

Collapsing candidates:

• E + I → single primitive? No — the OPERATION of hashing (I) is independent of what's hashed (E). Full E without I = typed blob. Full I without E = nothing to hash.

6 primitives stable under iteration.

3.5 Partial levels

Entity (E):

Identity (I):

Phase transition: I2→Full I. Content-addressing becomes deterministic and structural.

Tree (T):

Emit (M):

Phase transition: M2→M3. Reactive cascade — emit triggers handlers that emit further.

Execution (X):

Phase transition: X0→X2 (open dispatch). Most consequential — system becomes programmable.

Peer (P):

3.6 The 3+2+1 structure

E, I, T are primordial (eternal information — exist without time or agency). M, X are temporal (introduce time and computational agency). P is spatial (introduces position and perspective).

This structure corresponds to the abstract substrate's organization:

• {E, I, T} = Encoding + Structure = the substrate's information core
• {M, X} = Direction + Output + Evaluator = the substrate's functional machinery
• {P} = Boundary = the substrate's spatial extent

Step 4 — Dependencies

I → E    (hash requires something to hash)
T → I    (tree binds paths to identity-hashes)
M → T    (emit's Bind step mutates tree bindings)
X → T    (dispatch is a tree walk — the tree IS the dispatch table)
P → I    (peer ID is content-addressed)
P → X    (peer-to-peer interaction requires EXECUTE dispatch)

DAG:

E ← I ← T ← M
              ↑
         I ← P → X ← T

Hub: E (Entity) — everything ultimately depends on having typed data.

Coherent sub-lattice: 9 of 64 subsets.

{}, {E}, {E,I}, {E,I,T}, {E,I,T,M}, {E,I,T,X}, {E,I,T,M,X}, {E,I,T,X,P}, {E,I,T,M,X,P}

Filter: 9/64 = 14%. Tight — highly integrated substrate.

Three Hasse paths:

• Path α: E → EI → EIT → EITM → EITMX → EITMXP (emit before execution — Paper 0's build-up)
• Path β: E → EI → EIT → EITX → EITMX → EITMXP (execution before emit)
• Path γ: E → EI → EIT → EITX → EITXP → EITMXP (peer before emit)

Step 5-6 — Pairs and Load Classification

C(6,2) = 15 pairs.

Heavy (11):

Medium (1): IP (peer ID is content-addressed). Light (2): EM (entities are passive in emit), MP (cross-peer propagation is mediated). Negligible (1): EP (entities don't carry peer identity — peer-independent by design).

11 of 15 heavy (73%). Strong outlier — highest integration of any domain analyzed. Reflects deliberate design for all primitives to interact.

Step 7 — Coherent Sub-lattice

Computation

6 primitives, 2^6 = 64 total subsets.

Dependencies: I→E, T→I, M→T, X→T, P→I+X.

The chain E←I←T is strict — you need E for I, I for T, T for M and X. P needs both I and X.

Valid subsets must be downward-closed in the dependency order:

Invalid examples: {I} (needs E), {T} (needs I→E), {M} (needs T→I→E), {P} (needs I+X), {E,I,T,M,P} (P needs X — INVALID), {E,I,M} (M needs T — INVALID).

9 coherent subsets of 64. Filter: 9/64 = 14%. Tight — the strict chain E←I←T plus the double dependency P→{I,X} creates strong filtering.

Step 8 — Hasse Walks (Build-up Paths)

Three monotone paths from {} to {E,I,T,M,X,P}

Path α — Emit before execution (Paper 0's build-up):

{} → {E} → {E,I} → {E,I,T} → {E,I,T,M} → {E,I,T,M,X} → {E,I,T,M,X,P}

Information first: typed data (E) → content-addressed (I) → organized in tree (T) → observable mutation (M) → computation (X) → distribution (P).

This is the "information before computation" narrative. Each step adds a capability:

• E: data exists
• +I: data is identifiable
• +T: data is organized
• +M: data changes observably (versioning by construction appears here)
• +X: data is computable (reactive cascade appears here)
• +P: data is distributed (cross-peer sync appears here)

Path β — Execution before emit:

{} → {E} → {E,I} → {E,I,T} → {E,I,T,X} → {E,I,T,M,X} → {E,I,T,M,X,P}

Same informational base, but computation (X) before temporality (M). This builds a QUERYABLE STRUCTURED STORE before making it reactive. Computation is available before mutation is observable.

Path γ — Peer before emit (distribution first):

{} → {E} → {E,I} → {E,I,T} → {E,I,T,X} → {E,I,T,X,P} → {E,I,T,M,X,P}

Distribution (P) before reactivity (M). This builds a DISTRIBUTED DISPATCH SYSTEM before adding observable mutation. The system can route requests across peers before it tracks changes.

All three paths pass through {E,I,T} — the core triad is the BOTTLENECK. Every path must traverse it. After {E,I,T}, paths diverge based on which non-core primitive comes next.

Phase transitions along the paths

X0→X2 (open dispatch) is the MOST CONSEQUENTIAL transition — it's where the system becomes programmable. Before X2: fixed operations. After X2: extensible, user-defined computation.

Step 9 — Load-bearing Compositions

Core triad

{E, I, T} — self-describing content-addressed typed data at paths.

"What is a content-addressed typed datum at a path?" → An Entity (E) has an Identity (I = hash of canonical encoding) and lives at a path in a Tree (T).

Named compositions

Quad

{E, I, T, X} — Self-sustainability. Entity system can sustain itself: typed data (E), identifiable (I), structured (T), executable (X with bootstrap evaluator). Self-hosting. Requires X at X2+.

{E, I, T, P} — Coherent quad (EITP). Content-addressed typed data in a peer space, without the emit/execute reactive core. One of the dependency-coherent quads; the structural position AT Protocol occupies (cf. Paper 0). Distinct from the EITX self-sustainability quad.

Full set

{E, I, T, M, X, P} — Complete substrate (EITMXP). The full coherent six-primitive set: the entity system itself, at maximal substrate. The endpoint of every monotone Hasse path; should peak at the entity-system manifestation by a wide margin.

Step 10 — Emergent Properties

Step 11 — Cross-Domain Patterns

Comparison to other information substrates

The entity system is the most tightly integrated substrate (73% heavy pairs, 14% filter). Biology is tighter in filter (12.5%) but less integrated in pairs (40%). The entity system's high integration reflects deliberate design — every primitive was designed to interact with every other.

Abstract substrate role mapping

Maps to all 6 abstract substrate roles: En (E+I), St (T), Ev (X), Dr (M), Op (M), Bd (P). The M dual role (Direction + Output) is the entity system's most distinctive feature — emit IS both the trigger and the product.

Step 12 — Synthesis

What the entity system IS

A hard information substrate (Ev = Kd4) with 6 tightly integrated primitives, occupying the same structural role as biology's molecular machinery and cognition's symbolic apparatus. Its evaluator (handler dispatch) is deterministic by type system construction. Its encoding (typed entities with content-addressed identity) is self-describing. Its structure (tree namespace) organizes encoding hierarchically.

The entity system restores hard-substrate information integrity in a digital medium — the computational equivalent of biology's genetic code with ribosome.

Where it sits in its arrangement

Digital computing → [Entity→Digital bridge: Enc,Hsh,Prt,Prs,Sch,Net]
  → Entity system {E,I,T,M,X,P}
    → [Extensions as bridge: 12 extensions]
      → Application architecture {D,Sc,Re,Mu,Ra,Cn,Vs,Co,Au}
        → Digital ecosystem {not yet analyzed}

Summary

Referenced by the model

Cited as a source by 7 model records (browse the model census):

• entity-system — domain entity/sc1
• at-protocol — manifestation entity/sc3/at-protocol
• bitcoin — manifestation entity/sc3/bitcoin
• git — manifestation entity/sc3/git
• holochain — manifestation entity/sc3/holochain
• nostr — manifestation entity/sc3/nostr
• urbit — manifestation entity/sc3/urbit