Graph Semantics: Canonical Domain Analysis

Status: Canonical reference. Full 12-step analysis of the graph-level structure — what patterns emerge when multiple domains are analyzed, connected, and compared. Relationship to v1 meta-structure: The v1 meta-structure analysis (v1_abstract_analysis/analysis-meta-structure.md) found the graph's SYNTAX: {Domain, Edge, Composition, Identity} — what kinds of things the graph contains. This analysis finds the graph's SEMANTICS — what PATTERNS emerge when you populate the graph with multiple analyzed domains. Sources: v1_biology_domain_analysis/analysis-graph-semantics-full.md (exploratory analysis), v1_biology_domain_analysis/exploration-methodology-revision-and-graph-analysis.md (Layer 3 identification), full biology/cognition/entity system analysis series

Step 1 — Information Gathering

1.1 What we're analyzing

The structure that emerges from analyzing MULTIPLE domains and connecting them. Not the within-domain structure (Layer 1 — the 12-step methodology handles that) and not the between-domain connections (Layer 2 — edge types and bridge analysis). This is Layer 3: the patterns visible only when you step back and look at the graph AS A WHOLE.

1.2 What instances exist

Three complete multi-domain arrangements:

• Biology arrangement: Chemistry → Biology → Organism arch → Ecosystem, with Environment as context
• Cognition arrangement: Cognitive substrate → Cognitive arch → Cultural ecosystem, with physical/social environment as context
• Entity system arrangement: Digital computing → Entity system → App arch → Digital ecosystem (partial), with infrastructure as context

Fragments of others:

• Physics arrangement: Categorical base → Physics enrichments → SM, QM, GR (configuration cluster)
• Info-comp arrangement: Info-comp core → IT, CC, DS, NT (configuration cluster)
• Statistical mechanics arrangement: Microscopic → Macroscopic (realization pair with bridges)

1.3 What was discovered from comparing these

From the biology analysis series (/19), comparing the three complete arrangements revealed:

1. Invariant topology — the same graph shape across independent arrangements
2. Domain type classification — substrate/surface/ecosystem with predictable structural properties
3. Abstract mirror domains — info-comp core, abstract surface, abstract ecosystem
4. Meta-patterns — tight-loose-tight, core triad function by type, 6→9 expansion
5. Self-correction through constraint propagation — revising one domain cascades
6. The genesis transition — evaluator/decoder appearing

These are the SEMANTIC objects of graph-level analysis.

Step 1b — Domain Type Declaration

Type: Substrate

Graph semantics describes the machinery of structural knowledge production — how analyzing multiple domains produces generalizable structural knowledge. It processes information formally (structural vocabulary, consistency checking, constraint propagation). Its core operation is information flow: instances → classification → abstraction.

Predictions from substrate type:

• Filter tightness: ~12-20% (tight)
• Core triad function: information flow
• Dependency chain depth: moderate to deep
• Heavy pair count: approximately equals primitive count

Step 2 — Landscape Analysis

2.1 What recurs across graph-level analyses

Every instance of graph-level analysis (whether in this methodology, in comparative biology, in systems science, or in category theory) involves:

1. Concrete analyzed things — the specific systems/domains being compared
2. Classifications of those things by structural role
3. Generalizations from multiple instances at the same role
4. Connected structures — how the things relate to each other topologically
5. Cross-type regularities — patterns that hold across different classifications
6. Self-correction — revision when new instances don't fit

2.2 Related frameworks

Graph semantics synthesizes elements from all of these: category theory's structural precision, comparative biology's instance-based generalization, systems science's level awareness, and philosophy of science's attention to cross-level relationships.

Step 3/3b — Primitives and Partial Levels

3.1 Primitive extraction

Six candidate primitives, tested against the three criteria:

1. Instance (In) — A concrete analyzed domain with specific primitives, partial levels, dependencies, pairs, core triad, and manifestations.

• Structural minimality: without instances, the graph is empty — nothing to analyze. ✓
• Compositional productivity: instances compose into arrangements (connected instances), into type classes (instances at same role), and validate abstractions. ✓
• Empirical recurrence: biology, entity system, cognition, organism architecture, ecosystem, etc. ✓

2. Arrangement (Ar) — A connected structure of domains related through typed edges. The topological organization of multiple analyzed domains — how they connect, what shapes they form.

• Structural minimality: without arrangements, domains are isolated nodes — no structural relationships visible. ✓
• Compositional productivity: arrangements compose with other arrangements (parallel comparison), with types (typed positions within the arrangement), and with abstractions (multiple arrangements → shared structure). ✓
• Empirical recurrence: biology arrangement, cognition arrangement, entity system arrangement, physics configuration cluster, etc. ✓

Note: "Arrangement" replaces the earlier "Chain" primitive. Chains (linear realization sequences) are one specific arrangement shape. Other shapes include configuration clusters, enrichment hierarchies, decomposition trees, and mixed topologies. The methodology doesn't privilege any particular topology.

3. Type (Ty) — A classification of domains by structural role — what KIND of domain this is within its arrangement.

• Structural minimality: without type classification, all domains look equivalent — no prediction of structural properties from role. ✓
• Compositional productivity: types compose with arrangements (which type at each position?) and with patterns (types have predicted properties). ✓
• Empirical recurrence: substrate/surface/ecosystem distinction appears across all three complete arrangements. ✓

4. Abstraction (Ab) — The shared structural essence of multiple concrete domains at the same type-position — what ALL instances of a type have in common.

• Structural minimality: without abstraction, each domain is unique — no generalization, no prediction. ✓
• Compositional productivity: abstractions compose with other abstractions (abstract substrate → abstract surface) and with concrete instances (abstraction validates concrete). ✓
• Empirical recurrence: info-comp core, abstract surface, abstract ecosystem. ✓

5. Pattern (Pt) — A structural invariant that holds across types — a regularity in the graph that isn't specific to any one domain type.

• Structural minimality: without patterns, comparisons across types are ad hoc — no systematic regularities. ✓
• Compositional productivity: patterns compose into larger structural theories (tight-loose-tight + core triad functions + expansion mechanism = unified theory of domain types). ✓
• Empirical recurrence: tight-loose-tight, core triad function by type, 6→9 expansion, ~10 bridge mechanisms. ✓

6. Convergence (Cv) — Self-correction through constraint propagation — how the graph refines as new instances are analyzed, inconsistencies detected, and revisions cascade.

• Structural minimality: without convergence, analysis is one-shot — errors persist, the graph is brittle. ✓
• Compositional productivity: convergence drives the analytical process — each correction produces new predictions testable against new instances. ✓
• Empirical recurrence: info-comp 6→7, SSA 6→7, culture substrate→ecosystem reclassification. ✓

3.2 Reduction test

Is Instance reducible to Arrangement + Type? No — an instance has its OWN CONTENT (specific primitives, specific partial levels) not captured by just knowing its arrangement position and type. Two instances at the same position can have different primitive sets (biology {G,T,R,P,Reg,Mem} vs entity system {E,I,T,M,X,P}).

Is Pattern reducible to Type + Abstraction? No — patterns carry content BEYOND what types and abstractions alone provide. Tight-loose-tight IS a relationship between types, but it's a STRUCTURAL LAW governing how types relate, not derivable from any single type or abstraction.

Is Convergence reducible to the others? Flagged as potentially a dynamic property rather than a structural primitive. Test: does removing convergence forfeit a class of analytical moves? YES — without self-correction, wrong primitives stay wrong, and the methodology is brittle. Convergence enables the graph to IMPROVE, which is structurally distinct from having instances, arrangements, types, abstractions, or patterns.

3.3 Confirmed primitive set: 6 primitives

3.4 Partial levels

Instance (In):

Phase transition: In2→In3 (Cross-type instances). Below: patterns visible within a type (all substrates have ~6 primitives) but not ACROSS types. Above: cross-type comparison possible — tight-loose-tight becomes visible.

Arrangement (Ar):

Phase transition: Ar2→Ar3 (Complete subgraph). Below: fragments — a substrate relates to a surface, but no ecosystem, no context, no selection. Above: the FULL architecture — from substrate through surface to ecosystem with context and selection. This is where the invariant topology becomes visible. Realization chains, configuration clusters, enrichment hierarchies, and decomposition trees are all specific shapes at Ar3+.

Type (Ty):

Phase transition: Ty2→Ty3 (Extended types). Below: three main categories. Above: EVERY position in the graph has a type — bridges are a type, context is a type, selection is a type. The full invariant topology becomes typeable.

Abstraction (Ab):

Phase transition: Ab2→Ab3 (Abstract domain). Below: mapping primitives across instances, but the mapping is ad hoc — a table, not a domain. Above: shared structure IS A DOMAIN with its own primitives, dependencies, sublattice, core triad. Analyzable with the same methodology as concrete domains. This is where abstraction becomes PRODUCTIVE rather than merely comparative.

Genesis transition: Ab2→Ab3 requires multiple instances. You can't abstract from a single instance — you'd just restate its findings. You need 2+ independent instances (3 is better) to distinguish universal structure from particular content.

Pattern (Pt):

Phase transition: Pt2→Pt3 (Explanation). Below: pattern exists but you don't know WHY. Above: you understand the MECHANISM. This is where patterns become insights rather than observations.

Convergence (Cv):

Phase transition: Cv2→Cv3 (Cascade). Below: revisions are local. Above: revisions PROPAGATE — fixing one domain forces adjustments in connected domains. The graph becomes a coupled system that self-corrects globally.

Step 3c — Evaluator Identification

Graph semantics processes structural information. Its evaluator is the analyst's formal cognition (Kd3-4) — the ability to assess structural claims for consistency, completeness, and coherence.

This is a COGNITIVE evaluator, not a physical one (ribosome) or computational one (handler dispatch). It operates through cognition's formal mode — near-deterministic for structural analysis (is this dependency valid? does this filter match the type prediction?) but less reliable for heuristic judgments (is this primitive truly irreducible? is this the right core triad?).

The evaluator's reliability correlates with formality:

• Formal operations (computing sublattices, checking dependencies): Kd3-4
• Heuristic judgments (primitive identification, load classification): Kd2-3
• These correspond to the methodology's acknowledged soft spots (§2.3 of methodology.md)

Step 4 — Dependencies

In → (nothing; foundation — you need instances to analyze)
Ar → In (arrangements require 2+ connected instances)
Ty → In (type classification requires instances to classify)
Ab → Ty, In (abstraction requires typed instances to abstract over)
Pt → Ab, Ty (patterns require abstractions and types to observe patterns across)
Cv → Ar, Ab (convergence requires arrangements to propagate through and abstractions to revise)

DAG:

In (hub — no dependencies)
  ├── Ar ────────┐
  ├── Ty         │
  │     └── Ab ──┤── Cv
  └──────── Ab   │
              └── Pt

Hub: Instance (In). Everything requires analyzed domains. You can't classify types, build arrangements, abstract, discover patterns, or converge without concrete instances.

Terminal: Cv and Pt. Convergence requires arrangements + abstractions. Patterns require abstractions + types. Both are late-appearing capabilities.

Depth: Maximum chain: In → Ty → Ab → Pt (depth 3), or In → {Ar, Ty→Ab} → Cv (depth 3 through Ab). Moderate depth — consistent with substrate type.

Step 5 — Pair Enumeration

C(6,2) = 15 pairs.

Step 6 — Load Classification

Heavy pairs

Moderate/light pairs

10 heavy pairs of 15 (67%). Very high — tightly integrated. This reflects graph semantics being the INTEGRATION of all analytical concepts.

Check against substrate-type prediction

Predicted: heavy pair count ≈ primitive count (~6). Actual: 10. HIGHER than predicted — similar to the entity system's anomalously high integration (11/15 = 73%). Both the entity system and graph semantics are highly coupled systems where most concepts interact with most other concepts.

Step 7 — Coherent Sub-lattice

Dependency constraints

In must be present for anything else. Given In:

• Ar needs In only
• Ty needs In only
• Ab needs Ty + In
• Pt needs Ab + Ty
• Cv needs Ar + Ab

Enumeration

Valid subsets of {Ar, Ty, Ab, Pt, Cv} given In always present:

Invalid examples:

• {Ab}: needs Ty → INVALID
• {Pt}: needs Ab+Ty → INVALID
• {Cv}: needs Ar+Ab → INVALID
• {Ar, Ab}: Ab needs Ty → INVALID
• {Ty, Cv}: Cv needs Ar+Ab → INVALID
• {Ar, Ty, Cv}: Cv needs Ab → INVALID
• {Ty, Ab, Cv}: Cv needs Ar → INVALID
• {Ar, Ty, Pt}: Pt needs Ab → INVALID

Total including {} and {In}:

• {} (empty): 1
• {In}: 1
• {In + valid subset}: 10

Total: 11 coherent subsets of 64 (2^6) (the {} empty set is already one of the 11 enumerated above — not a separate "+1"; the earlier "= 12" double-counted {}).

Wait — total lattice is 2^6 = 64 (all subsets of 6 primitives). Let me recount:

• {} : 1
• {In} : 1
• {In, Ar} : 1
• {In, Ty} : 1
• {In, Ar, Ty} : 1
• {In, Ty, Ab} : 1
• {In, Ar, Ty, Ab} : 1
• {In, Ty, Ab, Pt} : 1
• {In, Ar, Ty, Ab, Pt} : 1
• {In, Ar, Ty, Ab, Cv} : 1
• {In, Ar, Ty, Ab, Pt, Cv} : 1

11 coherent subsets of 64 (the enumerated list above has exactly 11 entries, including {} — an earlier draft miscounted this 11-item list as "12"; corrected to match §11.1 and the validation table, which already state 17.2%, and an independent BFS of the §4 model = 11/64).

Filter: 11/64 = 17.2%. Tight.

Step 8 — Build-up Sequence

Primary path

Step 0→1: {} → {In}
  Analyze one domain. You have an instance. No connections, no classification.
  
Step 1→2: {In} → {In, Ar}
  Analyze a second domain and connect them through a typed edge. You have an
  arrangement — two domains in structural relationship. You can see how one
  relates to the other (realization, configuration, enrichment, etc.).
  
Step 2→3: {In, Ar} → {In, Ar, Ty}
  Classify the domains by structural role. "This one is a substrate, that one
  is a surface." You can predict structural properties from type.

Step 3→4: {In, Ar, Ty} → {In, Ar, Ty, Ab}
  Analyze more instances at the same type-positions across different arrangements.
  Abstract what they share. First abstract domain emerges.
  *** GENESIS TRANSITION ***
  Before: classified instances but no generalizations.
  After: abstract domains capturing what all instances of a type share.
  Analysis becomes PREDICTIVE — the abstract domain predicts properties of
  not-yet-analyzed instances.

Step 4→5: {In, Ar, Ty, Ab} → {In, Ar, Ty, Ab, Pt}
  With abstractions across types, observe META-PATTERNS — regularities that hold
  across types (tight-loose-tight, core triad functions, expansion mechanism).

Step 5→6: {In, Ar, Ty, Ab, Pt} → {In, Ar, Ty, Ab, Pt, Cv}
  Full system. The graph self-corrects. New instances trigger revisions.
  Revisions cascade through arrangements and abstractions. The structure
  converges toward stability.

The genesis transition: Step 3→4 (Ab appearing)

Abstraction from multiple instances IS the genesis transition for structural knowledge. You need at least TWO independent arrangements to abstract (one arrangement just restates its own findings). Three is better — it distinguishes universal structure from coincidental similarity.

This parallels genesis transitions in other domains:

• Info-comp: Kd appears (decoding makes information functional)
• SSA: Vr appears (evaluation makes encoding productive)
• Biology: ribosome emerges (translation makes genetic code functional)
• Graph semantics: abstraction emerges (generalization makes structural analysis predictive)

In each case, the genesis transition converts STATIC STRUCTURE into PRODUCTIVE CAPABILITY.

Alternative paths

Path B: {In} → {In, Ty} → {In, Ty, Ab} → {In, Ar, Ty, Ab} → ...

Classify first, then abstract, then build arrangements. This path works when you have multiple instances at the same type but haven't connected them into arrangements. You abstract from parallel analysis rather than connected structure. Both paths converge at Step 4.

Step 9 — Load-bearing Compositions

Core triad

{In, Ty, Ab} — Instance, Type, Abstraction.

"What is graph-level structural analysis?" → You have INSTANCES (concrete domains), classify them by TYPE (structural role), and ABSTRACT what instances of each type share.

All three pairs heavy:

• In-Ty: classify instances by type ✓
• In-Ab: validate abstractions against instances ✓
• Ty-Ab: each type has its abstract mirror ✓

This is the GENERALIZATION LOOP — the core operation of Layer 3 analysis.

Parallel to other core triads:

• Info-comp: {Σ, Ke, Kd} — symbols + encode + decode (information loop)
• SSA: {En, Vr, Se} — encode + evaluate + select (evolutionary loop)
• Graph semantics: {In, Ty, Ab} — instantiate + classify + abstract (knowledge loop)

All three describe loops: the info-comp loop processes information, the SSA loop evolves substrates, the graph semantics loop generates structural knowledge.

Secondary triad

{Ar, Ab, Cv} — Arrangement, Abstraction, Convergence.

"How does structural knowledge evolve?" → Build ARRANGEMENTS of connected domains, find shared ABSTRACTIONS, and CONVERGE through revision.

All three pairs heavy:

• Ar-Ab: comparing arrangements reveals shared structure ✓
• Ar-Cv: revisions propagate along arrangements ✓
• Ab-Cv: abstractions trigger and undergo revision ✓

Other named compositions

Quad composition

{In, Ar, Ty, Ab} — The complete generalization system. Instances connected into arrangements, classified by type, and abstracted across types. This quad is where ALL productive structural analysis happens — it's the minimum configuration for predictive structural knowledge.

Step 10 — Emergent Properties

The key emergent property: predictive abstraction

At {In ≥ In2, Ty ≥ Ty2, Ab ≥ Ab4}: abstract domains generate predictions for NOT-YET-ANALYZED concrete instances. You can predict a new substrate will have ~6 primitives, ~12-20% filter, information-flow core triad — BEFORE analyzing it. If the prediction fails, you learn something structural (either the prediction is wrong or the new instance reveals a novel pattern).

This is when the methodology becomes a SCIENCE rather than a classification exercise — it makes falsifiable predictions.

Step 11 — Cross-Domain Structural Patterns

11.1 Comparison to other substrate-type domains

All confirmed substrate-type: tight filters (11.7-17.2%), information-flow core triads, moderate dependency depths.

11.2 Graph semantics is a cognitive tool, not a substrate

Despite having substrate-like internal structure, graph semantics (the methodology's Layer 3) is NOT an autonomous information substrate. Testing against the SSA:

The substrate core {En, Vr, Mc} applies. The ecological envelope {Sf, Cx, Cm, Se} does not fully apply because graph semantics lacks AUTONOMY — it requires cognitive agents for surface production, community organization, and selection.

Classification: Graph semantics is a COGNITIVE TOOL — a manifestation at the cognitive architecture level, not a separate information substrate. It's comparable to mathematics, scientific method, formal logic, and programming: all are formal cognitive tools with substrate-like internal structure that depend on cognitive agents for operation.

Cognitive tools have the SSA's substrate core but not the ecological envelope. Full information substrates (biology, entity system, cognition) have both.

11.3 What this tells us about the SSA

The SSA's 7 primitives usefully divide into:

Substrate core {En, Vr, Mc}: Applies to ANY formal information processing system — substrates and cognitive tools alike. The core is GENERIC.

Ecological envelope {Sf, Cx, Cm, Se}: Applies only to AUTONOMOUS systems — those that produce function, form communities, and undergo selection without requiring external cognitive agency. The envelope is SPECIFIC to substrates.

This division explains why formal cognitive tools (methodology, mathematics, science) exhibit substrate-like internal structure: they have the generic core because they process information formally. But they're not substrates because they lack the autonomous ecological dimension.

Step 12 — Literature Alignment and Cross-Domain Mapping

12.1 Relationship to v1 meta-structure

The v1 meta-structure found the graph's SYNTAX: {Domain, Edge, Composition, Identity}. Graph semantics finds the SEMANTICS: {In, Ar, Ty, Ab, Pt, Cv}.

The syntax tells the GRAMMAR of the graph. The semantics tell what the graph MEANS when populated with multiple instances.

12.2 Relationship between the two primitive sets

These operate at different levels:

• {Domain, Edge, Composition, Identity} — the categorical structure of ANY graph (Level 0)
• {In, Ar, Ty, Ab, Pt, Cv} — the patterns that emerge in THIS KIND of graph when populated (Level 3)

The relationship is enrichment — graph semantics enriches the categorical base with specific semantic content. It's not realization (graph semantics isn't built FROM category theory in the physical sense). It's the same type of edge as "categorical base → physics enrichments" in the v1 abstract analysis.

12.3 Where cognitive tools sit in the realization graph

Cognitive substrate {Rp,Ct,As,Sq,Sy,Ev}
  → Cognitive architecture {Kw,Sk,Dc,Pl,Co,Jd,Cr,Si,Id}
    → [Cognitive tools: mathematics, science, methodology, programming, logic]
    → Cultural ecosystem {Pr,Ex,Tr,Dv,Cd,Gv,Te,Sc,Ct}

Cognitive tools are BRIDGE MECHANISMS between cognitive architecture and cultural ecosystem — they're HOW cognition produces transmissible, verifiable, cumulative knowledge. The methodology is one such tool, occupying a specific position in the cognitive architecture lattice:

Methodology position: Kw4/Sk3-4/Dc3/Pl3-4/Co3-4/Jd3-4/Cr3/Si1-2/Id2

The entity system was DESIGNED using cognitive tools (CS, math, logic) and OPERATES independently on digital computing. Genealogically from cognition, structurally independent on its own arrangement.

Summary

Domain characterization

Validation status

What this domain tells us about the methodology

1. Layer 3 has formal structure — 6 primitives, tight filter, heavy integration. It's not ad hoc.
2. The genesis transition for structural knowledge is ABSTRACTION — requiring 2+ independent instances to distinguish universal from particular.
3. The methodology is a cognitive tool — has substrate-like internal structure but requires cognitive agents for operation.
4. The SSA usefully divides into substrate core {En, Vr, Mc} (generic) and ecological envelope {Sf, Cx, Cm, Se} (autonomous only).
5. The convergence process is real — the graph self-corrects through constraint propagation, though correction requires cognitive agency.

Referenced by the model

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

• methodology-layer3 — domain methodology/sc1
• methodology — arrangement methodology/sc1