The Pair-Relationship Methodology

Status: Canonical reference. Promoted from v2 draft with additions from the biology/cognition/entity system/cognitive chain analysis series (through). Supersedes: v1_revision/methodology.md, methdology_domain_analysis/methodology-v2-draft.md Supporting analyses: methdology_domain_analysis/ (methodology self-analysis), abstract_info_domain_analysis/ (abstract domains), entity_domain_analysis/ (entity chain), cognitive_substrate_domain_analysis/ (cognitive chain), math_information_domain_analysis/ (information theory)

1. Overview

This document describes a methodology for structural analysis of domains. The methodology identifies irreducible primitives, their partial levels, pairwise interactions, and multi-primitive compositions to produce a structural characterization of a domain — what it is, how it works, and where it sits relative to other domains.

The methodology operates at four layers:

• Layer 1 (Domain Analysis): Analyze a single domain — identify its primitives, partial levels, dependencies, interactions, compositions, and manifestation positions. The 12-step process.
• Layer 2 (Graph Construction): Connect analyzed domains through typed edges — determine how domains relate, what content the edges carry, how primitives map across domains, and what cross-domain constraints exist.
• Layer 3 (Graph Semantics): Analyze the populated graph as a whole — discover arrangements, classify domain types, abstract shared structure, identify patterns, and converge through self-correction.
• Layer 4 (Applied Analysis): Instantiate structural knowledge for concrete situations — position specific entities across connected lattices, constrain by external context, compare against landscape, trace trajectories, and analyze cross-arrangement coupling. See §7.

Layers 1-3 are structural: they build abstract knowledge about domains and their relationships. Layer 4 is operational: it applies that knowledge to concrete entities in concrete contexts. The layers connect through feed relationships: Layer 1 produces what Layer 2 connects, Layer 2 builds what Layer 3 analyzes, all three feed Layer 4, and Layer 4 feeds back to Layer 1 when applied findings reveal gaps.

What the methodology produces

For a single domain: a primitive set with partial levels, dependency structure, pair-relationship classification, core triad, load-bearing compositions, phase transitions, and manifestation positions.

For cross-domain analysis: a typed graph of domains connected by edges with specific content. Constrained product lattices across connected domains. Multiple independent paths between domains giving different and complementary knowledge.

For graph-level analysis: domain type classifications, abstract domains capturing shared structure, structural patterns across types, and convergent self-correcting knowledge.

For applied analysis: unified manifestations (structural IDs of concrete entities), context-constrained feasibility, cross-arrangement coupling structure, trajectories through lattice positions over time, and actionable navigation from current position to target.

What the framework is and isn't

The framework is an analytical tool for structural understanding — a map of current knowledge that evolves as understanding deepens. It creates coordinate systems (domains) where systems can be precisely positioned, compared, and navigated.

It is not a physical simulation, not a formal mathematical theory (patterns are empirical, not proven), and not prescriptive (shows the landscape, doesn't dictate design choices). With mathematical development, it could become a computable structural analysis tool, bridge mathematics, or constraint-based model generator.

The methodology is not the Situated Substrate Architecture

A standing correction, because the practice keeps relapsing into it. The Situated Substrate Architecture (SSA) is not the methodology and is not its scope. The methodology is the four-layer process above. The SSA is one product of that process — a Layer-3 abstraction (§4): the invariant topology (substrate → surface → ecosystem, with context constraints and selection feedback) discovered by comparing three independently-analyzed information-substrate arrangements (biology, the entity system, cognition). It is highly useful for the questions it was discovered for — the structure of information substrates, and the parallels among computing, genetics, biology, and cognition — and it recurs across enormous scale (down toward physics).

That comprehensiveness is itself a trap. A structure that spans most of the realization chain connects to almost anything: pick any domain and you can draw real parallels to the SSA. Connectability is the nature of a comprehensive structure — it is not evidence that the domain must be analyzed as part of the SSA, nor that the domain's place in the SSA graph (node vs edge, which arrangement) needs to be resolved. Forcing every analysis to reconcile against the SSA is how analyses go off the rails — the architecture starts eating the work that motivated it.

Consequences for practice:

• Standalone domain analysis is first-class and normal. Many domains have been analyzed without placing them in the SSA — type systems, computational languages, user interfaces, strategic-analysis methodologies, the methodology itself. A new domain (e.g. value-exchange) is valid and useful on its own terms; it does not need an SSA home to earn its keep.
• Don't reflexively relitigate a domain's SSA placement. Whether a role is "a node" or "an edge," or which arrangement a domain belongs to, is a secondary and often open-ended question (potentially years of analysis to settle the right abstractions). It rarely changes the domain's content or its usefulness. Capture the open question, park it, and move on — do not let it consume the analysis that motivated it.
• The SSA is one Layer-3 pattern among potentially many (the Convergence Domain is another). What other large structures exist, and how the methodology behaves on domains that do not sit on the realization chain (governance, art, language, markets), is open. There may someday be an "SSA+" if the right abstractions are found; there is no such thing now, and reaching for it is not a release-time activity.
• The methodology analyzes and produces many things; the SSA is one of them. Reach for it as a lens when the question is about information substrates — not as the reality the methodology is about.

The structural vocabulary

The methodology operates with a specific vocabulary across its layers:

Layer 1: {Primitive, Level, Dependency, Interaction, Composition, Position} Layer 2: {Edge, Character, Substance, Mapping, Constraint} Layer 3: {Instance, Arrangement, Type, Abstraction, Pattern, Convergence} Layer 4: {Framework, Manifestation, Scope, Context, Landscape, Coupling, Trajectory}

Each term is defined precisely in its layer's section below. The vocabulary at each layer is the product of applying the methodology to itself — each term passes the three-test primitive criterion (minimality, productivity, recurrence). See methdology_domain_analysis/ for the full self-analyses.

2. Layer 1: Domain Analysis

2.0 The cycle's character

Layer 1 runs as an alternating construct-and-reduce cycle — a modern, iterated instance of the classical analysis/synthesis method (Pappus, Descartes, Newton; see primitives-history-nature-and-literature.md Part IV). Each pass builds the analytical structure forward (construct: posit primitives, lay out dependencies, predict properties) and then reduces (analyze: remove what can be absorbed, collapse what is redundant, retract what cannot be derived).

The cycle has a dialectical character: each reductive pass exposes a contradiction or redundancy in the current build (a primitive that turns out to be expressible from the others; a property that doesn't derive; a dependency that proves spurious), and the resolution is a higher unified structure that both negates the prior distinction and preserves what it was tracking, expressed at the type level rather than at the primitive level. The relay-insight cycle in the entity-system arc is the canonical worked example: twelve distinct message types (thesis) were exposed as redundant w.r.t. dispatch (antithesis), and resolved into "entities that manifest in peer contexts" with dispatch as the single primitive (synthesis).

Convergence is a bilateral fixed-point criterion: the cycle stops when (a) no candidate primitive can be removed from the set without losing a class of design moves the domain requires, AND (b) no candidate primitive can be added that is not recoverable from the existing primitives via the derivation discipline (Step 10b). Both directions must reach the fixed point — reduction stopping alone is not enough; addition stopping alone is not enough; both must.

2.1 The twelve steps

Step 1 — Information gathering. Read existing rigorous analyses, specifications, and literature for the domain before making claims. Skipping this step is where errors originate.

Step 1b — Domain type declaration. Declare whether the domain is substrate, surface, ecosystem, context, or bridge before analysis. See R11 in §2.4 for the predicted filter ranges, core-triad functions, and dependency-chain depths per domain type.

Step 1c — Level-of-description declaration. Declare the level of description at which primitives are to be extracted. Primitives are level-relative: chemistry's elements are irreducible at chemistry's level and reducible at particle physics's level. The declaration includes (i) what is accepted as primitive at this level without further reduction (the analytical floor), (ii) what is accepted as background without explicit modeling (the unmodeled context), and (iii) what assumptions hold about the level above (what the analysis takes as its consumer) and the level below (what the analysis takes as its substrate). The declaration makes the level-relativity of the resulting primitive set explicit and gives the reader a basis for evaluating the choice. Without this declaration, primitive-extraction debates often turn out to be about level-of-description disagreement rather than about the primitives themselves.

Step 2 — Landscape analysis. Survey existing instances in the domain. Landscape work orients the analysis — it shows what has been tried and what patterns recur.

Step 3 — Primitive extraction. Identify irreducible primitives via three tests:

• Structural minimality — removing forfeits a class of design moves
• Compositional productivity — combining with others yields new capabilities
• Empirical recurrence — shapes design decisions across diverse instances

This is analyst-judgment-heavy. Candidates get surfaced, tested, and consolidated.

Step 3b — Partial primitive decomposition. For each primitive, decompose internal structure into partial levels — a gradient from absent to fully elaborated.

This step produces a feedback loop with step 3: when you identify partial levels within a primitive, you often discover that one "primitive" is actually multiple bundled together, or that two "separate primitives" collapse into one at coarser resolution. The loop iterates until both the primitive set and partial-level structure stabilize. This iteration loop is the methodology's core reliability mechanism — it converts heuristic primitive guesses into stable primitive sets.

What partial primitive analysis produces:

• Levels per primitive (typically 4–6). Each level is a qualitatively distinct configuration.
• Phase transitions — certain level-changes are discontinuities, not gradual shifts. These mark qualitative behavioral changes.
• Position maps for real systems — concrete structural assessments, not vague comparisons.
• Compensation patterns — systems at low partial levels compensate with external mechanisms (the "layering trap").

Partial levels have internal structure (the recursive property). Any partial-level transition, when examined at sufficient resolution, decomposes into sub-levels with their own primitives, dependencies, phase transitions, and compositions — the same Layer 1 vocabulary recurring at finer grain. The methodology is scale-invariant: its analytical tools work at any resolution. The "right" granularity is determined by the question being asked. Scope (Layer 4 Sc) is the zoom control for this recursive structure. See §2.5.

Step 3c — Evaluator identification (optional). For information-processing domains, identify which primitive serves as the evaluator — the mechanism that translates encoding into function. Evaluator determinism (Kd level) is the most important structural variable separating hard substrates (Kd4: biology's ribosome, entity system's dispatch) from soft substrates (Kd1-2: cognition's linguistic mode, culture's conventions). Not all domains have evaluators — this step applies to information substrates specifically.

Step 4 — Dependency specification. For each primitive, identify what it presupposes. Not all subsets are coherent — dependencies filter the lattice. Dependencies apply at both primitive-presence and partial-level granularity.

Conditional partial-level dependencies. Some dependencies activate only above specific partial-level thresholds: Dep(A ≥ x, B ≥ y) means "primitive A at level x or above requires primitive B at level y or above." These are invisible at coarse (primitive-presence) resolution but tighten the coherent sub-lattice at fine resolution. They arise when fine-resolution advances in one primitive create problems that another primitive must solve, or require products that another primitive must provide. Confirmed across three arrangements: biology Dep(R ≥ 1.7, Mem ≥ 1), entity system Dep(X ≥ 3, P ≥ 2), cognition Dep(Sy ≥ 3, {Rp,Ct,As,Sq,Ev} ≥ 3). See biology_domain_analysis/ for the analysis that surfaced this concept.

Filter stringency — the percentage of the 2^n lattice that is dependency-coherent — is a measurable domain characteristic. At sub-level resolution, conditional dependencies produce tighter filter stringency than the coarse dependencies alone predict.

Step 5 — Pair enumeration. For n primitives, C(n,2) pairs. Each pair is a candidate site of structural interaction.

Step 6 — Load classification. Classify each pair as heavy, medium, light, or negligible. Four qualitative criteria:

1. Lines of spec or literature primarily about the pair
2. Number of extensions or mechanisms whose primary content lives in the pair
3. Number of failure modes distinctive to the pair
4. Number of emergent properties the pair contributes to

Step 7 — Coherent sub-lattice construction. Count valid subsets of the 2^n lattice given the dependency structure. This produces the Hasse diagram — the space of valid primitive configurations.

Two resolutions: primitive-presence (coarse, 2^n positions) and partial-level (fine, ~k^n positions). The partial-level lattice is where most analytical value lives. At sub-level resolution (when partial levels are decomposed into sub-levels per §2.5), the lattice expands further but conditional dependencies (Step 4) tighten the feasible region — the coherent sub-lattice at fine resolution is a NARROWER corridor through a LARGER space.

Step 8 — Hasse diagram walks. Trace monotone paths from the empty set to the full primitive set. Each path is a build-up narrative. Walks at partial-level resolution reveal phase transitions versus gradual elaboration.

Nested walks. A single step in a coarse Hasse walk (e.g., R0→R2 in biology) decomposes at fine resolution into a multi-step walk through a product sub-lattice — multiple primitives and bridge primitives co-advancing through a constrained corridor. The fine-resolution walk reveals internal phase transitions, bottleneck sub-steps, and rate variation invisible at coarse resolution. The nesting is recursive: sub-levels have sub-sub-levels, terminating at physics. See §2.5 and §6.5.

Step 9 — Load-bearing composition identification. Find subsets of primitives whose semantic content is irreducible — not recoverable from decomposition into smaller subsets. Triangles are the most common form, but quads and higher arities exist.

Step 10 — Emergent property prediction. Map load-bearing compositions at specific partial-level regimes to observable properties. These are testable predictions — they connect structural claims to empirical claims that can survive or fail against the world.

Step 10b — Derivation discipline. For every claimed emergent property at a composition, write an explicit derivation: how does the property emerge from the primitives' interactions, given the composition's structure and the partial-level positions of each primitive? The derivation must use only the primitive set, the dependency structure, the pair-relationship classification, and the composition rules established in earlier steps.

Derivation outcomes are graded on a four-level spectrum rather than binary success/failure:

1. Clean — the derivation goes through mechanically using only the primitive set + dependencies + composition rules. The property is structurally grounded; this is the unambiguous case.
2. Plausible — the derivation is a reasonable structural explanation but requires some interpretive judgment in mapping primitive interactions to the property. The property is grounded with caveats; flag the interpretive choices made.
3. Ambiguous — the property is empirically observed but multiple alternative derivations exist, or the structural mechanism is unclear at the current resolution. The property is not removed — empirical observation overrides derivation incompleteness. Flag for further analysis: sub-level decomposition (§2.5), 3/3b iteration, or additional composition rules might resolve the ambiguity.
4. Failed — no derivation appears possible from the current primitive set. One of three things is true:
   • The primitive set is incomplete — there is a missing primitive that the derivation implicitly requires. The 3/3b loop should be re-entered with this primitive as a candidate.
   • The property is mis-attributed to the wrong composition — the property exists but at a different composition that does derive cleanly. Move it.
   • The property is a higher-level observation that depends on additional context — escalate to a higher Sc level or add a context-domain dependency.

The discipline is conservative on removal: a property at status ambiguous is kept on the emergent map with a flag, not removed. Removal requires a failed derivation that survives 3/3b iteration and sub-level decomposition. Empirical observation outweighs analytical derivation when the two disagree — the methodology's job is to make the disagreement explicit, not to police the empirical record.

All four outcomes are informative. Derivation failures or ambiguities are findings the methodology produces, not failures of the methodology. The discipline produces a derivation set alongside the emergent property map; the derivation set records the status of each property and the reasoning that established it.

The discipline is the methodology's analogue of Wierzbicka's Natural Semantic Metalanguage (NSM) paraphrase test, where every concept must be paraphrasable using only ~65 cross-linguistically-stable semantic primes; paraphrase failure indicates either a missing prime or that the concept lies outside the metalanguage's scope. The methodology's version operates on structural emergent properties at compositions rather than on natural-language concepts, but the discipline is the same — the procedure's outputs must be recoverable from the procedure's primitives, and recovery failure is the test.

Step 10 (prediction) and Step 10b (derivation) play complementary roles. Predictions check against the world (empirical validity); derivations check the methodology's internal coherence (structural validity). A claim that predicts correctly but cannot be derived is a successful empirical observation about the domain, not a structural finding about the primitive set. A claim that derives cleanly but predicts wrongly indicates a structural derivation that doesn't match how the domain actually behaves, suggesting either a model error or a domain anomaly worth examining.

Step 11 — Structural pattern observation. Cross-domain step. Observe which patterns replicate across domains.

Step 12 — Literature alignment and cross-domain mapping. Where literature exists, check findings against existing analyses. Where cross-domain structure is relevant, map primitives to other domains' implementations.

2.2 What produces the meaningful structure

The highest-value outputs:

1. Partial primitive decomposition (step 3b) — makes landscape analysis concrete and structurally comparable
2. The Hasse diagram at both resolutions — shows where real systems sit and what paths are available
3. Load-bearing compositions at any arity — the irreducible structural units carrying emergent properties
4. The emergent property map — connects structure to predictable behavior, making the analysis falsifiable
5. The derivation set (step 10b) — the methodology's structural validity check. Each emergent property in the map is accompanied by a derivation that explains how the property arises from primitives' interactions. The derivation set is what makes the analysis internally coherent rather than merely descriptive.

2.3 Acknowledged soft spots

Where the methodology relies on analyst judgment:

• Primitive identification — when is a candidate "irreducible enough"? Mitigated by the 3/3b iteration loop.
• Partial level boundaries — how many levels, where to draw boundaries? Guided by landscape observation.
• Load classification — heavy/medium/light are qualitative. A quantitative metric would ground this but has not been implemented.
• Irreducibility criterion for compositions — "can this be recovered from smaller subsets?" is hard to apply mechanically.
• Dependency vs regime — is a constraint structural dependency or design-choice regime? Sometimes unclear.

2.4 Methodological refinements (R1-R13)

R1. Name the domain kind explicitly. Substrate-domain primitives are discovered via structural necessity; application-domain primitives are selected via design choice.

R2. Mark dependency-filter stringency. Report the coherent-subset count as a percentage of the full 2^n lattice.

R3. Distinguish firm from borderline compositions.

R4. Add a literature-mapping step. The triangulation test should be explicit.

R5. Add a cross-domain-mapping step when applicable.

R6. Honesty about count-sensitivity. Accompany primitive count claims with alternatives considered.

R7. Engage existing rigorous analysis first. Surface-level analysis without engaging specs produces material errors.

R8. Mode A → Mode B zoom operation. When a domain has existing dimensional analysis, pair-relationship analysis can be applied directly to the dimension set.

R9. Candidate-primitive triage. Three outcomes: dimensional (add), reducible (absorb), scope-excluded (note).

R10. Architectural asymmetry acceptance. Sub-systems within the same broader system can have different primitive counts.

R11. Domain type declaration (Step 1b). Declare whether the domain is substrate, surface, ecosystem, context, or bridge before analysis. The declaration predicts filter range, core triad function, and dependency chain depth. Substrate: tight filter (~12-20%), information-flow core triad. Surface: loose filter (~25-40%), functional-integration core triad. Ecosystem: tight filter (~7-20%), resource-flow core triad. These ranges are empirical observations from information substrate analyses and may not generalize to all domain types.

R12. Level-of-description declaration (Step 1c). Declare what is accepted as primitive at the chosen level of description (the analytical floor), what is accepted as background (the unmodeled context), and what assumptions hold about adjacent levels. This refinement made the level-relativity of the primitive set explicit. Several primitive-extraction debates in the corpus turned out to be level-of-description disagreements rather than disagreements about the primitives themselves — once the level was declared, the disagreement either resolved or sharpened into a clear question about which level is most useful for the analytical question. The level-of-description declaration also clarifies what the recursive partial-level decomposition (§2.5) is doing: it is re-entering primitive extraction at a finer level, with a new analytical floor and a new background.

R13. Bilateral fixed-point criterion (§2.0). The cycle stops only when both reduction and addition reach fixed points. Reduction-side: no candidate primitive can be removed without losing a class of design moves the domain requires. Addition-side: no candidate primitive can be added that is not recoverable from the existing primitives via the derivation discipline (Step 10b). The bilateral discipline was made explicit when M3 (Step 10b) was added; before that, the addition side was implicit (the analyst stopped adding when "it felt complete"), which left the stopping rule under-specified. The bilateral criterion is the methodology's analogue of the classical analysis/synthesis tradition's stopping question — when have we reached fundamental principles? — answered structurally rather than foundationally.

Cross-domain observations from continued application. As the methodology has been applied across more domains, certain observations have surfaced that are not refinements to the procedure itself but are worth recording where they can be consulted by future analyses. They include: (a) the primordial-axis recurrence — every analyzed substrate manifests informational, temporal, and spatial aspects, with the specific proportions (and the size of the cross-cutting bucket of primitives spanning axes) varying by substrate; (b) the multi-surface coherence condition — when a substrate's primitives are predominantly operations that produce stable content units distinct from themselves, a separate content-surface domain can be extracted independently of the behavioral surface (the cognition arrangement is the canonical case; biology and the entity system probably do not have this in the same clean form); (c) the scope distinction within Step 1c — for domains where the same primitives can be analyzed at single-mind and multi-mind scopes (NSM-like cases), the scope must be declared explicitly to avoid conflating cognitive content with community-stabilized content. These observations are developed in detail in Paper 11 §Cross-Domain Structural Patterns and §The primordial intuition and open questions; they are recorded here as procedure-adjacent notes rather than as new R-level refinements because the procedure itself is unchanged.

2.5 Sub-level analysis (the recursive property)

Partial levels have internal structure. Any partial-level transition, when decomposed at finer resolution, reveals sub-levels that exhibit the same structural patterns: sub-level primitives, dependencies, phase transitions, compositions, and positions. The methodology's analytical vocabulary is scale-invariant — it produces meaningful structure at any resolution.

When to decompose. Sub-level analysis is warranted when a transition is poorly understood, when a phase transition needs mechanism explanation, or when the coarse walk hides internal bottlenecks. Not every transition needs decomposition — coarse resolution is sufficient for structural comparison and landscape analysis.

What sub-level decomposition produces:

• Finer sub-levels (typically 5–10 within a single coarse transition). Each is a qualitatively distinct molecular/structural configuration.
• Conditional partial-level dependencies — dependencies invisible at coarse resolution that tighten the feasible corridor (Step 4).
• Internal phase transitions — discontinuities within a single coarse transition. These identify the mechanism of the coarse transition.
• Rate variation — not all sub-steps take equal time. The lattice provides topology (what can happen); physics provides rate (how fast each step occurs). The slowest sub-step is the internal bottleneck.
• Product corridor — the walk through sub-levels is not a single-primitive advance but a multi-primitive walk through a constrained product sub-lattice, with multiple coordinates (domain primitives, bridge primitives, context) co-advancing.

Three structural patterns observed at sub-level resolution:

1. Autocatalytic spiral. Two or more primitives co-advance through a positive feedback loop within a partial-level transition. Each cycle improves both primitives. The spiral has a critical threshold — below it, improvement is linear; above it, exponential. Observed in evolved substrates (biology: ribosome-protein bootstrap; cognition: language-thought spiral). Absent in designed substrates (entity system: evaluator built directly). The spiral is the signature of evolved genesis.

2. Crystallization. A phase transition where a structural variable FREEZES — becomes permanent, irreversible, and universal. Properties: (a) irreversible — the frozen state cannot be undone without destroying all downstream dependents; (b) enabling — downstream primitives depend on the frozen value for stability; (c) universal — all instances share the same frozen state. Distinct from attractors (stable but mutable) and walls (blocking but crossable). Observed: genetic code (biology, accidental), dispatch semantics (entity system, intentional), grammar (cognition, local). Crystallization occurs when enough downstream entities depend on a structural variable that changing it would simultaneously invalidate all of them.

3. Pre-separation fusion. Before genesis transitions in information substrates, the encoding and evaluator are FUSED — the same molecular/structural entity performs both roles. The genesis transition IS the separation of encoding from evaluation. The SSA topology (7 roles) is a PRODUCT of genesis, not its precondition. The transition has three phases: (a) pre-separation (En and Vr fused), (b) architectural genesis (En and Vr separate, evaluator at Kd1-3), (c) functional genesis (evaluator reaches Kd4, tangent set explosion).

4. Composite gates. Some load-bearing primitives advance only when MULTIPLE upstream primitives simultaneously cross specific partial-level thresholds. The advancement is gated by the conjunction of conditions, not by any single one. The canonical case is cognition's symbolization gate: full Sy_sym requires simultaneous threshold crossings on six bridge primitives (population coding, Hebbian learning, sequence generation, reward signaling, hierarchical processing, motor decoding). Until ALL six reach their thresholds, the gate is closed; once they do, full Sy_sym becomes accessible and the downstream cognitive architecture primitives that depend on it (full Language Acquisition, Creativity Emergence, Identity Construction) all unlock together. Composite gates produce CORRELATED ADVANCEMENT — when any one gate-input is bottlenecked, the entire composite is blocked, and when the bottleneck resolves the downstream cascade releases simultaneously. They explain why some phase transitions appear ABRUPT in observation (the gate releases all at once, not via gradual primitive-by-primitive accumulation) while taking long absolute times underneath (each gate-input must independently advance to its threshold).

Nesting terminates at physics. The recursive decomposition stops when sub-levels reach physical constants and quantum states — the bottom of the realization spine. Physics provides the rate function at every level; the methodology provides the structural topology.

3. Core Vocabulary

Primitive

A minimal irreducible structural unit of a domain, meeting three criteria: structural minimality, compositional productivity, empirical recurrence.

Primitives have partial levels — a gradient from absent to fully elaborated. Each level is a qualitatively distinct configuration. Typical count: ~6 primitives per domain (range 4–12 observed across 20+ domains).

Partial Level

A qualitatively distinct configuration within a single primitive's gradient. Boundaries drawn where real systems show qualitative behavioral differences.

Partial levels are scope-relative — "Full" is the analyst's current ceiling, not an absolute limit. They are discrete milestones — qualitatively distinct. Continuous parameters within or between milestones are not primitives.

Dependency

A structural relation where one primitive presupposes another. Filters the 2^n lattice to its coherent sub-lattice.

Dependencies apply at both primitive-presence and partial-level granularity.

Phase Transition

A discontinuity in partial-level progression where qualitative behavior changes. Two types: within-domain (within a single primitive) and cross-edge (in bridge primitives, gating elaboration in connected domains).

Pair-Relationship (Interaction)

A bivariate interaction between two primitives when both are active. Classified as heavy, medium, light, or negligible by four qualitative criteria.

Load-Bearing Composition

A subset of primitives (at any arity) whose emergent properties are irreducible. Triangles are most common. Load-bearing compositions often require specific partial levels to activate.

Core Triad

A 3-primitive subset where all three pairs are heavy AND the triangle is load-bearing. Operationally defines "what the domain IS." Core triad function varies by domain type: information flow (substrates), functional integration (surfaces), resource flow (ecosystems).

Hub Primitive

A primitive that most others depend on or relate to. Every domain analyzed has one or two.

Anchor Pair

A heavy pair that serves as a semantic attractor for load-bearing compositions.

Manifestation

A specific actual system occupying a position in a domain's lattice. Manifestations have identity (distinguishable), trajectory (they move through the lattice over time), scaffolding (ad-hoc compensation for partial positions), and properties determined by position.

A manifestation can be a point (a specific instance — single position per chain level) or a population (a class of systems sharing structural commitments — range of positions per chain level). Both are unified manifestations under the same primitive; the population case carries ranges where the point case carries integers, and population membership reduces to range containment of constituent points. Confirmed in Phase 1 (entity arrangement).

The lattice is a possibility space, not a progress axis. Systems at partial positions are not deficient — partial positions have real advantages (lower complexity, specific optimization).

Conditional Partial-Level Dependency

A dependency that activates only above a specific partial-level threshold: Dep(A ≥ x, B ≥ y). Invisible at coarse (primitive-presence) resolution. Tightens the coherent sub-lattice at fine resolution. Arises when fine-grained advances create problems (parasite control, coordination) or require products (enzymes, peer awareness) from another primitive.

Autocatalytic Spiral

Two or more primitives co-advancing through a positive feedback loop within a partial-level transition. Each cycle of the spiral improves both primitives. Has a critical threshold separating linear (trickle) from exponential (flood) regime. Signature of evolved genesis; absent in designed genesis.

Crystallization

A phase transition where a structural variable freezes — becomes permanent, irreversible, and enabling. All downstream dependents rely on the frozen value; changing it would simultaneously invalidate them all. Distinct from attractors (convergent, mutable) and walls (blocking, crossable). The genetic code, dispatch semantics, and grammar are instances.

Ambient Primitive

A primitive at one analytical level that becomes the assumed medium at a higher level, disappearing as an explicit primitive.

Context Domain

A domain whose primitives describe external operating conditions that constrain other domains from outside. Context is the SSA's independent root — it constrains surface and community without being produced by the substrate. Context primitives describe STATES regardless of origin (natural or accumulated from prior activity). Every analyzed arrangement has a context domain: biology has environment {En,Cl,Ch,St,Tm,Db}, cognition has context {Rb,Gs,Po,If,Ks,Th}, the entity system has digital context {Cm,Pl,Lb,Co,Sd,Pr}. Typically ~6 primitives.

Context feedback loops. Context primitives are not always passive boundary conditions. Specific context-internal pairs can form feedback loops where one primitive's level amplifies another's, producing accelerating co-evolution of context state independent of the substrate or community. The canonical case is cognition's Ks–Tr cycle: knowledge stock (Ks) accumulation amplifies transmission technology (Tr) capability, which amplifies further Ks accumulation. The cycle exhibits exponential acceleration: writing (centuries to advance Ks one level) → printing (decades) → networked digital (years). Such feedback loops are structurally distinct from the SSA's three primary cycles (niche construction, adaptation, full evolutionary); they live entirely within the context domain. Context feedback loops are an Sc=2/Sc=3 dynamical phenomenon — they require rate models to be quantitatively analyzed but are visible at Sc=1 as conditional partial-level dependencies between context primitives.

Evaluator

The primitive within an information substrate that translates encoding into functional output. Evaluator determinism (Kd level) is the critical structural variable: Kd4 (deterministic) defines hard substrates (biology's ribosome, entity system's dispatch). Below Kd4: information tool. At Kd4+: information substrate.

Split evaluators. A substrate's evaluator may be SPLIT — different modalities within the same substrate operate at different Kd levels. Cognition's symbolization (Sy) is the canonical case: formal modes (mathematics, logic, code) operate at Kd4 (deterministic), while linguistic modes (natural language, gesture, narrative) operate at Kd1–Kd2 (variable, context-dependent). The same substrate primitive thus produces both reliable formal systems AND lossy natural-language transmission simultaneously. Split evaluators explain why some information substrates exhibit both high-fidelity persistence and high-flexibility variation as load-bearing structural features rather than as a defect.

4. Layer 2: Graph Construction

4.1 The inter-domain graph

Analyzed domains connect via a typed graph. Domains are nodes — each with its own primitive set, lattice structure, and population of manifestations. Typed edges connect them. The graph grows with analysis and is never "complete."

The graph is NOT a numbered hierarchy. It is a DAG (or more generally, a graph with possible cycles through feedback edges) with typed edges. The structure is categorical: domains are objects, edges are morphisms, edge composition is morphism composition.

4.2 Edge types

Edges between domains are classified by character — what kind of structural relationship they represent:

Realization — How a system is physically realized in its substrate. Has bridge primitives (computational translation machinery). Exists where there is a substrate gap — the upper system operates in a different medium than the lower. Direction: from substrate toward the system it enables.

Role identification — What structural role each primitive plays in an abstract framework. No bridge primitives — just a mapping table. Enables comparison via shared abstract roles.

Configuration — A domain IS an abstract framework at specific partial-level settings. No new primitives — the domain selects which regimes to emphasize. Direction: from abstract to specific.

Enrichment — Adding specific mathematical structure to an algebraic base. Specific to domains that ARE mathematical structures. The enrichments are primitive-like (partial levels, pair structure) but combine orthogonally with the base.

Decomposition — How application-domain primitives implement via substrate primitives. May have bridge-like content (not yet formally analyzed as bridge primitives).

Feedback — Bidirectional influence where surface activity modifies the context for substrate activity. Discovered in the biology analysis (niche construction).

Selection — Evaluative influence where community structure evaluates surface performance, propagating to encoding via the evaluator. Discovered in the biology analysis.

Coupling — Structural connection between domains in DIFFERENT arrangements, where instances from one arrangement interact with instances from another. Unlike realization (within-chain medium translation), coupling connects separate chains that were analyzed independently.

Coupling edges have distinctive properties:

• Bidirectional — both chains affect each other (human uses software AND software shapes human)
• Multi-level — coupling exists at multiple domain levels simultaneously (physical, semantic, social)
• Interface-mediated — the coupling passes through specific primitives that serve as cross-chain connection points
• Lossy — information is transformed or lost crossing chains
• Reciprocally characterized — the same coupling carries different kinds depending on direction. From manifestation A's perspective, coupling to B may be scaffolding (B provides primitives A lacks); from B's perspective, the coupling to A may be substrate-foundation (A provides primitives B builds on). Both characterizations are valid simultaneously; neither is the "true" view. The coherent thing is the coupling itself; the kinds are perspective-relative. (Phase 1 example: Git → GitHub scaffolding / GitHub → Git substrate-foundation.)

Coupling connects specific primitives across arrangements. Three coupling types observed:

• Physical coupling — organism sensing/response ↔ application interface (screen, touch, audio)
• Semantic coupling — cognitive judgment/decision ↔ application content/access (meaning, navigation)
• Social coupling — cultural coordination ↔ digital ecosystem (mediated social interaction)

Coupling has partial levels corresponding to dimensionality of the interface (1D sequential → 2D spatial → 3D immersive) and depth of engagement (protocol implementer → application developer → end user).

The edge type set is empirically extensible — new types are added when found. The current set of 8 is not known to be complete.

4.3 When edges have bridge primitives

Bridge primitives exist when there is a substrate gap — the upper system's primitives operate in a different medium than the lower system's, and specific translation machinery is required.

Bridge primitives are structurally identical to domain primitives — they have partial levels, pair structure, core triads, phase transitions. They are analyzed using Layer 1's full 12-step methodology (Layer 1's vocabulary is EMBEDDED within Layer 2's substance analysis).

The only difference is location: bridge primitives live on an edge rather than in a node. They ARE the translation machinery.

Extracting a bridge into canonical form. When a bridge analysis exists in prose and needs to be promoted into a canonical artifact (per the project layout in canonical-architecture-strategy.md §Part 5: data/bridges/<name>.v1.json), the extraction follows a six-step procedure: (1) enumerate the bridge mechanisms as primitives; (2) define partial levels for each, with the same partial-level discipline as domain primitives (qualitatively distinct configurations, not arbitrary scalars); (3) for each bridge primitive, identify which source-domain primitive pairs it exercises and which target-domain primitives it produces; (4) compute the filter stringency on the bridge's coherent sub-lattice using the same coherence-checking procedure as domains; (5) identify core triads or hub mechanisms within the bridge; (6) validate against the source prose analysis to confirm no structural content is dropped. Bridges have the same JSON schema as domains plus a small set of bridge-specific fields (source_chain_level, target_chain_level, optional cross-lattice constraints). When a bridge crosses arrangements (e.g., the bio→neural-hardware bridge connecting biology and cognition arrangements), it is still a bridge in this sense; the cross-arrangement coupling is captured at the arrangement-definition level, not by a different bridge schema.

4.4 Edge composition

Edges compose through shared domains. Composition is typed — not all type combinations compose meaningfully.

4.5 Product lattices and feasible regions

When domains are connected by realization edges, their lattices combine into product spaces:

Upper domain lattice × Bridge lattice × Substrate lattice

Not all positions in the product are coherent. Constraints reduce it to a feasible region — the set of positions where all cross-domain constraints are satisfied.

The feasible region's boundary is where minimal viable configurations live: abiogenesis thresholds, minimum viable implementations.

4.6 Category theory's dual role

Category theory appears in two distinct ways:

1. As a node — the categorical base {Object, Morphism, Composition, Identity} is a domain that mathematical structures (physics) build on via enrichment.
2. As the meta-language — the graph itself has categorical structure. This isn't imposed; it follows from "relating structured things with composable relationships" being what a category IS.

These roles shouldn't be conflated.

5. Layer 3: Graph Semantics

5.1 What Layer 3 does

Layer 3 operates on the populated graph as a whole — not on individual domains (Layer 1) or individual edges (Layer 2), but on patterns that emerge from the graph's structure when multiple domains are analyzed and connected.

5.2 The six primitives

5.3 The genesis transition

The genesis transition at Layer 3 is abstraction from multiple instances (Ab appearing). Before: classified instances but no generalizations. After: abstract domains capturing what all instances of a type share. This is when the methodology becomes predictive — the abstract domain predicts properties of not-yet-analyzed instances.

The genesis transition requires at least TWO independent arrangements. Three is better — it distinguishes universal structure from coincidental similarity.

5.4 The convergence mechanism

The graph self-corrects through constraint propagation:

1. New instance analyzed (Layer 1)
2. Compared against existing abstractions (Layer 3)
3. Mismatch detected — instance doesn't fit current abstraction
4. Abstraction revised (or instance re-analyzed)
5. Revision cascades through connected domains

This convergence is DIRECTED (by the analyst's cognitive evaluation), not autonomous (like biological evolution). The methodology gets better with use because its predictions get validated or revised against each new domain.

5.5 Arrangements are topology-general

Arrangements can take any shape:

• Realization sequences (linear chains from substrate to surface to ecosystem)
• Configuration clusters (abstract framework → multiple specific domains)
• Enrichment hierarchies (algebraic base → enriched structures)
• Decomposition trees (system → application domains)
• Mixed topologies (combinations of the above)

The methodology doesn't privilege any particular arrangement shape. Different edge types produce different topologies.

5.6 Empirical patterns across domain types

The following patterns have been observed across 3+ independent arrangements (biology, entity system, cognition). They are empirical — confirmed across information substrates but not proven universal.

Tight-loose-tight filter pattern. Substrates have tight filters (~12-20%), surfaces have loose filters (~25-40%), ecosystems have tight filters (~7-20%). Tight filters constrain the design space; loose filters allow more independent variation.

Core triad function by type. Substrate core triads handle information flow. Surface core triads handle functional integration. Ecosystem core triads handle resource flow.

6→9 expansion. Substrates have ~6 primitives. Surfaces have ~9 (range 7-12). Ecosystems have ~9. The core triad becomes ambient at the surface level; the non-core primitives expand ~3×.

~10-12 bridge mechanisms. Each realization edge has ~10-12 bridge primitives with their own core triad, hub structure, and phase transitions.

Invariant topology. Every complete information substrate arrangement (substrate → surface → ecosystem + context + selection) produces the same graph shape — the Situated Substrate Architecture (SSA).

6. Navigation

6.1 Position and tangent set

At any point in a domain's lattice, a manifestation occupies a specific position — a tuple of partial-level assignments. The tangent set T(P) is the set of single-step advances available from the current position, given dependency constraints within the domain AND feasibility constraints across edges.

Some moves are immediately available. Others are blocked — they require bridge or substrate advances first. The blocked moves and their blocking constraints are the most actionable output.

6.2 Paths and path optimization

Multiple paths exist between any current position and a target. They differ in sequence, bridge requirements, intermediate capabilities, and phase transition encounters.

Optimization criteria:

• Minimal total steps → shortest path
• Maximum enabling → through phase transitions (each step opens the most new moves)
• Minimal bridge cost → stays within current substrate capability
• Maximum intermediate value → every step produces a usable system

6.3 Attractors and the layering trap

Certain lattice positions are attractors — positions where many independent systems converge. Attractors are stable because they deliver clear value while the NEXT step requires significant bridge infrastructure with non-obvious payoff.

Systems at attractors build scaffolding — ad-hoc bridge primitives compensating for partial positions. The layering trap is when scaffolding accumulates to the point where advancing actual primitives requires dismantling the scaffolding.

Walls: advancing requires destructive changes (dismantling scaffolding). Hard to cross. Fences: advancing is additive. Easier to cross.

At coarse primitive-presence resolution the lattice is monotonic by construction — adding a missing primitive is always additive in principle. Wall character must therefore originate somewhere finer than coarse: in partial-level commitments, in design details below partial-level resolution, or in some other substructure. Determining whether a specific manifestation faces a wall vs a fence requires deeper analysis the model does not currently capture; current wall/fence assignments reflect analyst judgment, not derived model output. See methodology-advanced-topics.md for the in-progress refinement and §10 for the open question on substrate substructure.

6.4 Co-evolutionary walks

When domains are connected by realization edges, their manifestations advance alternately, each enabling the next. This is a co-evolutionary walk in the joint feasible region.

At sub-level resolution, co-evolutionary walks reveal their detailed mechanism: the walk zigzags through a product corridor, advancing different coordinates (domain primitives, bridge primitives, context) in alternating sequence. Each advance in one domain enables or requires advances in connected domains. The corridor is shaped by conditional partial-level dependencies, bridge co-evolution constraints, and context conditions.

Walk rate variation. Not all steps in a co-evolutionary walk take equal time. The lattice provides the topology (which positions are reachable); physics provides the rate (how fast each step occurs, determined by thermodynamic costs, kinetic barriers, search space sizes, and information-theoretic limits). The slowest sub-step is the internal bottleneck. Layer 4's trajectory (Tj) is where topology meets rate.

Three nested timescales. Co-evolutionary walks in information substrate arrangements operate at three coupled timescales: niche construction (ecological: surface↔context, fast), selection (evolutionary: community→substrate, medium), and full evolutionary (geological: substrate→surface→community→context→substrate, slow). Fast cycles equilibrate within each slow-cycle timestep — the same scale separation as statistical mechanics.

6.5 Reverse walks (convergent reconstruction)

When the endpoint of a walk is known (the present state, or a well-characterized historical state), the walk can be reconstructed BACKWARDS from structural constraints:

1. Start from the known endpoint
2. Identify structural necessities — what transitions MUST have occurred (dependencies, phase transitions)
3. Map the product constraints — what must co-exist at each sub-level for coherence
4. Infer the walk trajectory from the constraints and the known endpoint
5. Validate against empirical evidence where available

Reverse walks are powerful because the structural constraints are often tight enough to predict the walk's topology (which sub-levels exist, in what order, with what dependencies) even when the specific mechanism is uncertain.

The abiogenesis analysis (biology domain: biology_domain_analysis/) is a reverse walk: starting from R2 (universal genetic code — all life shares it), reconstructing the sub-level sequence back to R0 (prebiotic chemistry). The universality of the genetic code PROVES single origin and constrains the walk to a single path through the product corridor.

Reverse walks complement forward walks (traditional Hasse walk from empty set to full): forward walks explore possibility space; reverse walks reconstruct actual trajectories from known endpoints. Both are constrained by the same product lattice, but reverse walks have the advantage of a known target that further constrains the feasible corridor.

6.6 Sub-lattice state space exploration

When a specific transition is the subject of analysis, the full lattice can be narrowed to the relevant sub-lattice — the product space of all primitives that change during that transition, at sub-level resolution.

Procedure:

1. Identify the transition boundaries — the starting and ending positions in the coarse lattice
2. Decompose the changing primitives — identify sub-levels for each primitive that advances during the transition (Step 3b at finer resolution)
3. Identify co-varying bridge and context coordinates — which connected-domain primitives also change during the transition
4. Construct the product sub-lattice — the space of all sub-level positions across all changing coordinates
5. Apply conditional dependencies — filter the product sub-lattice to its coherent region
6. Walk the corridor — trace the constrained path through the product sub-lattice, identifying bottleneck sub-steps, internal phase transitions, and rate variation

The product sub-lattice is always a SMALLER space than the full lattice (fewer coordinates, focused on one transition), but at FINER resolution (more levels per coordinate). The feasible corridor through the sub-lattice is typically narrow — most positions are incoherent at fine resolution.

When to do this: When the mechanism of a specific transition matters — for understanding genesis events, predicting bottlenecks, or identifying the internal structure of phase transitions. Not needed for structural comparison or landscape analysis, where coarse resolution is sufficient.

6.7 Design opportunity discovery

Coherent but unpopulated lattice positions are design opportunities — configurations the dependency structure permits but no existing system occupies. These are structural predictions.

7. Layer 4: Applied Analysis

Layer 4 instantiates the structural knowledge from Layers 1-3 for concrete situations. Where Layers 1-3 produce abstract structural maps, Layer 4 uses those maps to analyze specific entities interacting in specific contexts at specific times.

Full domain analysis (methdology_domain_analysis/analysis-applied-analysis.md) confirms Layer 4 has its own irreducible primitive set, internal structure, and unique outputs not available from Layers 1-3 alone.

7.0 The seven primitives

Hub: Manifestation (Mn, 5 heavy pairs). Independent root: Context (Cx). Anchor pair: Mn-Cx (entity-in-context).

Three core triads branching orthogonally from the anchor pair:

              Sc (scope — at what level?)
              |
        Mn —— Cx (anchor: entity-in-context)
       / \
      Ls   Tj
  (space)  (time)

• {Mn, Cx, Sc} — Analytical Frame: entity-in-context-at-scope
• {Mn, Cx, Ls} — Strategic Positioning: entity-in-context-among-peers
• {Mn, Cx, Tj} — Trajectory Planning: entity-in-context-over-time

Filter: 29.7% (38/128 coherent). Matches Layer 1 exactly.

Dependencies: Fw → {Mn, Sc}. Mn → {Ls, Cp, Tj}. Cx independent. Scope and Manifestation are siblings — both depend on Framework, neither depends on the other.

Three genuinely new concepts not in Layers 1-3: Scope (Sc) adds specificity control, Context (Cx) adds external constraint, Trajectory (Tj) adds temporal dynamics. Layers 1-3 are always at universal scope and static; Layer 4 adds the ability to analyze at any specificity level and through time.

Key phase transitions: Sc0→Sc1 (universal→constrained: domain-specific constraints enter), Sc2→Sc3 (abstract→physical: for physical domains, physics becomes load-bearing), Fw2→Fw3 (description→structure), Cx2→Cx3 (described→actionable), Tj2→Tj3 (descriptive→predictive).

Scope determines primitive character. Strategy/tactics/operations are the SAME analysis at different Sc levels: strategy = Sc0-1, tactics = Sc2-3, operations = Sc3-4. See guide-applied-analysis-concepts.md for operational patterns including ontogenetic pathways, OODA mapping, and multi-scope analysis.

7.1 Unified manifestation

A unified manifestation is a specific entity's position across ALL connected lattices in its arrangement. It captures the entity's structural ID across multiple domains.

U(entity) = (
  Domain₁ position:  (P₁₁, P₁₂, ..., P₁ₙ)
  Bridge₁₂ levels:   (B₁₁, B₁₂, ..., B₁ₘ)
  Domain₂ position:  (P₂₁, P₂₂, ..., P₂ₙ)
  ...
  Domainₖ position:  (Pₖ₁, Pₖ₂, ..., Pₖₙ)
)

For a software system in the full entity arrangement, this is 73 dimensions: 6 (hardware) + 6 (bridge) + 6 (computing) + 6 (bridge) + 6 (substrate) + 12 (bridge) + 12 (surface) + 10 (bridge) + 9 (ecosystem).

When unified manifestation is substantive vs trivial:

• Substantive for realization edges — bridge primitives create independently variable lattice positions at each level. Two systems can share a substrate position but differ at the surface. The unified manifestation captures this independent variation.
• Trivial for configuration or role-identification edges — positions are just different views of the same coordinates. No independent variation, no bridge machinery. The unified manifestation collapses to a single position with an abstract label.

Unified manifestations are the methodology's most comprehensive structural description of a single entity. They enable precise comparison: Git and Postgres occupy the same computing position (standard) but diverge sharply at the substrate level (Git: I-Full, M0, X0; Postgres: I0, M2, X3).

7.2 Context domains

Every analyzed arrangement has a context domain — an independent root that constrains what is achievable without being produced by the substrate. Context explains why the same substrate potential produces different outcomes at different times and places.

Three context domains analyzed:

• Biology environment {En,Cl,Ch,St,Tm,Db} — energy, climate, chemistry, substrates, temperature, disturbance
• Cognitive context {Rb,Gs,Po,If,Ks,Th} — resources, geography, population, infrastructure, knowledge stock, threat
• Digital context {Cm,Pl,Lb,Co,Sd,Pr} — compute, platform, libraries, community, standards, pressure

Context domains share structural properties: ~6 primitives, independent root (not produced by the substrate chain), some primitives are natural and some are accumulated from prior ecosystem activity (the natural/cultural entanglement), and specific feedback loops where context and ecosystem co-evolve.

Context constrains the tangent set. A system's moves are constrained not only by its internal position (dependencies) and its arrangement's edge constraints (bridge levels), but also by the context it operates in. A full-substrate system in a low-context environment has the POTENTIAL but not the ACHIEVABILITY. Context determines which moves in the tangent set are actually available.

Context bottleneck analysis. For a given system, which context primitives are below the level required for the system's target position? The entity system's context bottleneck analysis: Community (Co2-3) is the ONLY bottleneck — all other digital context primitives are at sufficient levels.

7.3 Cross-arrangement coupling

When instances from different arrangements interact, the interaction occurs through coupling — the cross-chain edges described in §4.2. Applied analysis maps specific coupling instances.

A developer using an entity system application instantiates coupling at three levels simultaneously:

Organism arch (Sn,Rs) ←→ App arch (Pc,Pn)     — physical coupling (screen, keyboard, touch)
Cognitive arch (Si,Jd,Dc) ←→ App arch (D,Ac)   — semantic coupling (meaning, navigation, choice)
Cultural eco (Cd,Tr) ←→ Digital eco (Ig,Ex)     — social coupling (mediated interaction)

Each coupling level connects specific primitives. The coupling has:

• Directionality — input flow and output flow (often asymmetric)
• Bandwidth — how much information crosses per unit time
• Fidelity — how accurately cross-chain transmission works (developer intent → user experience)
• Dimensionality — 1D sequential (CLI), 2D spatial (GUI), 3D immersive (VR/game), corresponding to coupling partial levels

The UI domain analysis found two non-overlapping core triads: {E,S,V} (reactive interaction — physical coupling dimension) and {E,C,Σ} (accessible composition — semantic coupling dimension). This is the only analyzed domain with two core triads. Physical and semantic coupling aren't separate edges — they're the SAME coupling structure at different dimensionality levels. A 1D interface couples physically; a 2D+ interface couples both physically and semantically; accessibility breaks when you build for high dimensionality without ensuring the semantic coupling is sound.

7.4 Trajectories

A trajectory is a manifestation's path through the lattice over time — the sequence of positions it has occupied and the transitions between them.

Trajectories operate at multiple time scales:

• Development trajectory — how a system is built up over months/years (entity system: 146K lines across three implementations, currently at ~28/60 on app architecture)
• Evolutionary trajectory — how a deployed system changes over its lifecycle (Git's substrate frozen in 2 weeks, ecosystem evolving for 20 years)
• Historical trajectory — how an entire domain advances through epochs (8 computing epochs from mainframe to AI)

Trajectory analysis reveals:

• Substrate freeze — lower levels freeze before upper levels, always. Protocols freeze at standardization. Applications freeze at product-market fit. Only platforms continuously elaborate.
• Build-up order — universal within a domain. Application architecture: D → Sh → Mt → Ac → Pc+Pn → Bn → Au → Pg → Ch → Hs → Ev (data model first, UI second, operational third, advanced last).
• Lifecycle patterns — Ship-and-Done (curl), Feature Plateau (Word), Continuous Elaboration (AWS), Version-Cycle (React), Evolve-or-Die (Instagram).
• Coupling-driven advancement — once a manifestation's substrate is frozen, further advancement of its position can come from couplings to other manifestations rather than from the substrate itself. The trajectory's solo position stays fixed while its joint position (computed against an active coupling) continues to advance. Phase 1 example: Git's substrate frozen 2005-07; ecosystem advancement 2008–2024 is GitHub-coupling-driven. Captured in data/trajectories/*.v1.json via per-snapshot couples_with.

Trajectories compose with context: the same system in different contexts follows different trajectories. The entity system in 2005 context (Cm3, Pl3, Lb2, Co0, Sd2) would follow a slower trajectory than in 2026 context (Cm4, Pl4, Lb4-Full, Co2-3, Sd3-4).

7.5 Instantiated analysis

The full instantiated analysis combines unified manifestation, context, coupling, and trajectory for a specific situation. This is the methodology's most concrete output — it tells you where a specific thing IS, what constrains it, what it interacts with, and where it can go.

The instantiation event. A particular moment where specific instances from specific arrangements interact in a specific context. Example: "A developer (cognitive chain, Kw4/Sk3/Cr3) uses the entity system workbench (digital chain, app arch at 28/60) in the 2026 digital context (Co2-3 bottleneck) to build a knowledge-base application."

The instantiation event has:

• Participants — unified manifestations of the interacting instances
• Context — the context domain's current position constraining what's possible
• Coupling structure — which primitives connect across chains, at what partial levels
• Available moves — the tangent set for each participant, constrained by context and coupling
• Trajectory prediction — where each participant is likely to move next, given current constraints

What instantiated analysis produces:

1. Bottleneck identification — which context primitive, coupling level, or bridge level is the binding constraint? The entity system's bottleneck is Co2-3 (community size), not substrate completeness.
2. Path recommendation — given current position, context, and coupling, what's the highest-value next move? For the entity system: surface development (L3-L5 SDK) rather than deeper substrate work.
3. Coupling optimization — where does the cross-chain coupling lose the most fidelity? Between developer intent and user experience, which coupling level needs work?
4. Context projection — how will context changes affect the trajectory? If community grows (Co3→Co4), what new moves become available?

7.6 Limits of applied analysis

The methodology's power varies with Scope. At Sc0-Sc1 (universal/class): structural analysis is powerful — primitives, lattice positions, bottlenecks, trajectories, and landscape comparisons are reliable. At Sc2 (configuration): the methodology can propose architectures and identify concerns but cannot validate specific design choices — that requires prototyping. At Sc3+ (instance/event): the methodology identifies which quantities matter and where to look but cannot predict specific values — that requires measurement.

The Sc1→Sc2 transition is the methodology's power boundary. Above it: analyze. Below it: build and test. Scope makes this boundary explicit.

The interface/coupling analysis (/21) hit this limit: the methodology identified the UI domain's 6 primitives and 2 core triads (Sc0 structural findings — reliable) but couldn't resolve what presentation entities look like or how workspace state transfers between devices (Sc2-Sc3 design choices — need prototyping and measurement).

The boundary: the methodology tells you the LANDSCAPE of possible designs (Sc0-Sc1) and the CONSTRAINTS on viable ones. Choosing among viable designs (Sc2+) requires building, testing, and measuring. See guide-applied-analysis-concepts.md §9 for the full scope-to-validation mapping.

8. Meta-Structure

8.1 The methodology applied to itself

The methodology's own structural elements form four primitive sets (one per layer):

Layer 1: {Primitive, Level, Dependency, Interaction, Composition, Position}

• Hub: Primitive. Core triad: {Primitive, Level, Dependency}. Filter: 29.7%.
• Two branches: Structure (Pm→Ix→Cp) and Grounding (Pm→Lv→Ps).

Layer 2: {Edge, Character, Substance, Mapping, Constraint}

• Hub: Edge. Core triad: {Substance, Mapping, Constraint}. Filter: 25%.
• Two branches converging: Character (Ed→Ch→Sb) and Mapping (Ed→Mp), meeting at Cn.

Layer 3: {Instance, Arrangement, Type, Abstraction, Pattern, Convergence}

• Hub: Instance. Core triad: {Instance, Type, Abstraction}. Filter: 18.75%.
• Genesis transition: Abstraction appearing (analysis becomes predictive).

Layer 4: {Framework, Manifestation, Scope, Context, Landscape, Coupling, Trajectory}

• Hub: Manifestation (5 heavy). Core triads: {Mn,Cx,Sc}, {Mn,Cx,Ls}, {Mn,Cx,Tj}. Filter: 29.7%.
• Three branches from Mn-Cx anchor: scope (Sc), spatial (Ls), temporal (Tj).

8.2 How the layers connect

Layer 1 produces what Layer 2 connects. Layer 2 builds what Layer 3 analyzes. All three feed Layer 4. Layer 4 feeds back to Layer 1.

Layer 1 ──feed──→ Layer 2 ──feed──→ Layer 3
   \                  |                /
    \──decomposition─→ Layer 4 ←─feed─/
                         |
                         └──feedback──→ Layer 1

Layer 1's vocabulary is EMBEDDED within Layer 2: bridge primitives (Layer 2's Substance at high levels) are analyzed using Layer 1's full 12-step process.

Layer 4's Framework primitive (Fw) IS the combined output of Layers 1-3. Layer 4's Manifestation (Mn) extends Layer 1's Position to unified cross-domain positions. Layer 4's Coupling (Cp) extends Layer 2's edge types to instantiated cross-chain interaction. Layer 4 adds three concepts absent from L1-3: Scope (Sc, specificity control), Context (Cx, external constraint), and Trajectory (Tj, temporal dynamics).

Filter pattern across layers: 29.7% → 25% → 18.75% → 29.7%. Layers 1-3 get progressively tighter. Layer 4 returns to match Layer 1 — structural and applied analysis have the same filter stringency.

Total primitives across all four layers: 24 (6 + 5 + 6 + 7).

8.3 The categorical spine

The methodology's graph is a category: domains as objects, edges as morphisms, composition as morphism composition. This is not imposed — it follows from the structure of relating structured things with composable relationships.

Each domain also has internal categorical structure (primitives as objects, dependencies as morphisms). The full structure is a 2-category or enriched category.

8.4 Graph constraints

The methodology constrains analytical depth, not structural breadth:

• Any topology is possible (chains, trees, DAGs, cycles, arbitrary)
• Any domain with decomposable structure is analyzable
• Edge types are empirically extensible
• The three-test primitive criterion constrains how rigorously you analyze, not what you analyze

9. The Situated Substrate Architecture

The SSA is the invariant topology discovered across three independent information substrate arrangements (biology, entity system, cognition). It is not a separate layer of the methodology — it is a Layer 3 abstraction (a Pattern) that every complete information substrate arrangement converges to.

9.1 The seven primitives

9.2 The invariant graph shape

En → Vr → Mc → Sf → Cm ← Se
                 ↕        ↕
                 Cx  ←→  Cm

Three cycles:

1. Niche construction: Sf → Cx → Cm → Se → Sf
2. Adaptation: Se → Sf → Mc → Vr → En
3. Full evolutionary: the complete loop

9.3 Confirmed instances

9.4 Abstract characterizations of SSA components

Each SSA component has an abstract domain describing what all instances share:

The abstract bridge domain describes the six structural concerns shared by ALL mediation edges (realization and coupling): Reference (how targets are identified), Boundary (how contexts separate), Persistence (how things endure over time), Composition (how pieces combine), Selectivity (what controls interactions), Transmission (how signals reach destinations). Hub: Reference. Star topology. Confirmed across 14 bridges in 3 chains. Does NOT apply to enrichment, configuration, or role-identification edges. Concrete domains map these abstract concerns to their own vocabulary — the abstract names describe structural ROLES, not domain-specific implementations. See analysis-abstract-bridge.md for full analysis.

10. Open Questions

1. Is the edge type set finite or open-ended? The current 8 types are empirically discovered. No theory of what types must or can't exist.

2. Do decomposition edges have bridge-like content? Entity system extensions ARE bridge primitives connecting substrate to application surface. The abstract bridge analysis confirms: the 12 extension mechanisms implement the six abstract bridge concerns {Rf,Bd,Ps,Cm,Sl,Tm} at high differentiation (~2 mechanisms per concern). The extension set is structurally complete. Remaining question: do ALL decomposition edges have this property, or only those that function as realization bridges?

3. Is Convergence (Cv) a structural primitive or a dynamic property? It passes the primitive test but sits uncomfortably between structure and process.

4. What mathematical development would most strengthen the methodology? Quantitative heaviness metrics, formal Galois connections for cross-domain mappings, and computational lattice tools are highest priority.

5. How many instances are needed for reliable abstraction? Two is suggestive, three is convincing. Is there a minimum for specific confidence levels?

6. Layer 4 revised to 7 primitives after 3/3b iteration. The initial analysis found 6 primitives. Persistent confusion about physics/abstraction during review triggered 3/3b revision, surfacing Scope (Sc) as a 7th primitive. Revised: 7 primitives, 3 core triads, 29.7% filter. Three genuinely new concepts (Scope, Context, Trajectory). The Scope primitive resolves the universal/particular distinction — when "Git" means the category vs a specific instance. Stress testing against additional analytical traditions (systems dynamics, phylogenetics) would further validate.

7. Does the SSA generalize beyond information substrates? All three confirmed instances are information substrates. Physics domains have different structure (enrichment hierarchies, not realization chains). Whether non-information substrates (if they exist) produce the same invariant topology is unknown.

8. How does coupling compose with realization? When a coupling edge connects surfaces from different realization chains, the full structure is: chain₁ (substrate→surface) ↔ coupling ↔ chain₂ (surface←substrate). Does the coupling have its own bridge primitives? The UI domain analysis suggests it does — the 6 UI primitives {E,S,V,L,C,Σ} might be coupling-bridge primitives, not a standalone domain.

9. What is the relationship between context domain feedback loops and ecosystem dynamics? Context domains have feedback loops (Lb-Ru in digital, Ks-Tr in cognitive) that accelerate over time. Are these the same phenomenon as ecosystem selection dynamics, or structurally distinct?

10. Where does wall/fence character actually live in the structural model? At coarse primitive-presence the lattice is monotonic, so wall character cannot originate there. Phase 1 showed (entity arrangement, 4 incoherent positions) that all coarse-distance-1 cases are analytically distinct: some look like additive fences (e.g., Git could gain Ap via API publication), others look like walls requiring restructure (Postgres needs full identity-model rewrite to gain content-addressing; Instagram needs business-model restructure to open-source; Nostr's flatness IS its identity). Where this distinction lives in the model is unresolved — partial-level commitments are one candidate, design-detail substructure below partial-level resolution is another. A "genetic-code analog for software's programming-code" — whatever frozen sub-primitive structure determines whether a manifestation can elaborate additively or must restructure first — has not been analyzed. Until this analysis is done, wall vs fence assignments to specific manifestations reflect analyst judgment rather than derived model output. See methodology-advanced-topics.md for the in-progress refinement.

Referenced by the model

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

• structural-primitive-analysis — manifestation methodology/sc3/structural-primitive-analysis
• abiogenesis — topology abiogenesis/sc1
• biology — topology biology/sc1
• entity — topology entity/sc1
• methodology — topology methodology/sc1