Domain Analysis: Canonical Domain Analysis of the 12-Step Methodology

Status: Canonical reference. The methodology's Layer 1 (single-domain analysis — the 12 steps) treated as a domain and analyzed with its own tools. Relationship to other analyses:

• v1 meta-structure (v1_abstract_analysis/analysis-meta-structure.md) analyzed the GRAPH — found {Domain, Edge, Composition, Identity}
• Graph semantics (analysis-graph-semantics.md) analyzed the PATTERNS across graphs — found {In, Ar, Ty, Ab, Pt, Cv}
• This document analyzes the WITHIN-DOMAIN process — what structural vocabulary the 12 steps operate with

Step 1 — Information Gathering

1.1 What we're analyzing

The 12-step domain analysis methodology — the process of taking a coherent structured domain and producing a structural characterization of it. This is the methodology's Layer 1: what happens when you analyze ONE domain.

1.2 Sources

• The methodology document itself (methodology.md, ~1800 lines)
• 17+ domain analyses performed using the methodology: entity system (6 primitives), biology (6), organism architecture (9), cognitive substrate (6), cognitive architecture (9), ecosystem (9), cultural ecosystem (9), environment (6), chemistry (6), info-comp core (7), programming languages (6), databases (7), user interfaces (6), capabilities (7), types (7), physics domains, dynamical systems, network theory, etc.
• The methodology advanced topics document
• The biology analysis series that tested and extended the methodology

1.3 What recurs across all 17+ applications

Every application of the methodology involves the same structural vocabulary:

1. Identifying irreducible THINGS (primitives)
2. Decomposing their GRADIENTS (partial levels)
3. Establishing ORDERING between them (dependencies)
4. Classifying their PAIRWISE INTERACTIONS (heavy/light pairs)
5. Finding MULTI-WAY STRUCTURES that carry emergent content (compositions)
6. POSITIONING real systems in the resulting space (manifestations)

These six recurring elements are the candidate primitives.

Step 2 — Landscape Analysis

2.1 The landscape of structural analysis methods

The methodology's approach sits within a broader landscape of structural analysis:

2.2 What's distinctive about this methodology

Compared to other structural analysis methods:

• Unlike dimensional analysis: operates on qualitative structure, not quantitative dimensions
• Unlike factor analysis: structural, not statistical — identifies conceptual primitives, not latent variables
• Unlike the axiomatic method: empirical, not formal — patterns are observed, not proven
• Unlike taxonomy: analyzes the SPACE of possibilities (lattice), not just actual instances
• Unlike ontology engineering: has the pair analysis and composition identification steps — finds WHERE structural content concentrates, not just what concepts exist

The distinctive contribution: the pair-relationship analysis (steps 5-6) and composition identification (step 9) that locate where emergent structural content lives. Other methods identify the parts but not the interaction structure between parts.

Step 3/3b — Primitives and Partial Levels

3.1 Candidate primitives

Six structural elements that the 12-step methodology operates with:

1. Primitive (Pm) — An irreducible structural unit of a domain. The fundamental building block that the methodology identifies. Tested by structural minimality, compositional productivity, and empirical recurrence.

• Structural minimality: without primitives, there's nothing to analyze — the domain has no structure. ✓
• Compositional productivity: primitives combine into pairs, compositions, lattice positions. ✓
• Empirical recurrence: every analyzed domain has primitives (6-9 per domain, consistently). ✓

2. Level (Lv) — A qualitative gradient of a primitive — how much of the primitive is present, from absent to fully elaborated. The partial level decomposition.

• Structural minimality: without levels, primitives are binary (present/absent) — can't position systems precisely or identify phase transitions. ✓
• Compositional productivity: levels compose with dependencies (level-dependent constraints), with positions (multi-primitive level configurations), and enable phase transition identification. ✓
• Empirical recurrence: every analyzed domain has partial levels (typically 4-6 per primitive). ✓

3. Dependency (Dp) — A presupposition ordering between primitives — what requires what. Structural constraints that filter the lattice.

• Structural minimality: without dependencies, all primitive combinations are equally valid — no structural constraints, no filtering, no build-up narrative. ✓
• Compositional productivity: dependencies produce the coherent sublattice (filtered space), build-up paths (Hasse walks), and phase transitions (level-dependent gates). ✓
• Empirical recurrence: every domain has dependencies, with filter stringency ranging from ~12% to ~56%. ✓

4. Interaction (Ix) — A pairwise relationship between two primitives — the structural content that lives at the intersection of two primitives. Classified as heavy, medium, or light.

• Structural minimality: without interactions, primitives are independent — no structural content between them, no emergent properties from combinations. ✓
• Compositional productivity: interactions compose into triangles and higher compositions. Heavy pair identification locates where structural content concentrates. ✓
• Empirical recurrence: every domain has C(n,2) pairs with consistent heavy-pair patterns (typically heavy count ≈ primitive count). ✓

5. Composition (Cp) — A multi-primitive structure whose content is irreducible — not recoverable from decomposition into smaller subsets. Triangles, quads, and higher arities.

• Structural minimality: without compositions, the analysis stops at pairwise interactions — misses emergent properties that require 3+ primitives simultaneously. ✓
• Compositional productivity: compositions carry emergent properties, map to testable predictions, and identify the domain's most distinctive structural features. ✓
• Empirical recurrence: every domain has named compositions, with the core triad being the most important. ✓

6. Position (Ps) — A specific location in the lattice — a concrete system placed at particular partial levels across all primitives. The manifestation.

• Structural minimality: without positions, the analysis is abstract — the lattice exists but nothing occupies it. No connection to real systems. ✓
• Compositional productivity: positions compose with other positions (comparing systems), with phase transitions (which positions are accessible), and with build-up paths (trajectories through the lattice). ✓
• Empirical recurrence: every domain analysis places real systems at lattice positions. ✓

3.2 Reduction test

Is Level reducible to Primitive? No — a primitive identifies WHAT the structural unit is; a level identifies HOW MUCH of it is present. These are independent axes. A primitive without levels is binary (present/absent). A level without a primitive is meaningless (a gradient of nothing).

Is Dependency reducible to Interaction? No — dependency is about ORDERING (A requires B), while interaction is about CONTENT (A and B together carry structural meaning X). You can have a heavy interaction between independent primitives (no dependency) or a dependency between lightly interacting primitives. They're orthogonal.

Is Composition reducible to Interaction? No — a composition carries content that its constituent pairs do NOT carry individually. The core triad's meaning exceeds the sum of its three pairs. That's the irreducibility criterion.

Is Position reducible to Primitive + Level? Partially — a position IS a specific level-assignment across all primitives. But positions have properties beyond individual level assignments: they're subject to dependency constraints (not all positions are coherent), they sit on build-up paths, and they have neighbors in the lattice. Position is the GROUNDING primitive that connects the abstract lattice to concrete reality.

3.3 Confirmed primitive set: 6 primitives

3.4 Partial levels

Primitive (Pm):

Phase transition: Pm2→Pm3 (Stabilization). Below: candidates are identified but may be wrong — the 3/3b iteration hasn't converged. Above: the iteration has stabilized — adding partial levels didn't split or merge any primitives. This is where the analysis becomes trustworthy.

Level (Lv):

Phase transition: Lv2→Lv3 (Phase transitions). Below: levels are a gradient — more or less of the same thing. Above: specific level boundaries are QUALITATIVE BREAKS where the system's behavior changes discontinuously. Phase transitions are where the lattice develops its most important structural features.

Dependency (Dp):

Phase transition: Dp1→Dp2 (Level dependencies). Below: primitives either require each other or don't — binary. Above: dependencies are LEVEL-SENSITIVE — A at high level requires B at high level, but A at low level is compatible with B absent. This is where the partial-level lattice becomes structurally rich.

Interaction (Ix):

Phase transition: Ix1→Ix2 (Load classification). Below: pairs exist but you don't know where the structural content concentrates. Above: you know WHICH pairs carry the domain's structural weight. This is where the domain's architecture becomes visible — heavy pairs reveal the structural skeleton.

Composition (Cp):

Phase transition: Cp1→Cp2 (Core triad identification). Below: candidate triangles exist but none is distinguished. Above: one triangle is identified as the domain's DEFINING structure — the composition that answers "what IS this domain?" This is the most interpretive step in the methodology.

Position (Ps):

Phase transition: Ps1→Ps2 (Level positioning). Below: coarse — you know a system has some primitives. Above: precise — you know WHERE in the gradient each primitive sits. This is where structural comparison becomes concrete: "Holochain has I3 where entity system has I-Full" is a specific, actionable characterization.

Step 4 — Dependencies

Pm → (nothing; foundation — you need primitives before anything else)
Lv → Pm (levels are OF primitives)
Dp → Pm (dependencies are BETWEEN primitives)
Ix → Pm (interactions are BETWEEN pairs of primitives)
Cp → Ix (compositions are built from interaction analysis — you need to know which pairs are heavy)
Ps → Pm, Lv (positioning requires primitives and their levels)

DAG:

Pm (hub — no dependencies)
  ├── Lv ──── Ps
  ├── Dp
  └── Ix ──── Cp

Hub: Primitive (Pm). Everything depends on identifying primitives first. Without primitives, there are no levels to decompose, no dependencies to specify, no pairs to analyze.

Two independent branches from Pm:

• Content branch: Pm → Lv → Ps (primitives → levels → positions). This is the GROUNDING path — connecting abstract structure to concrete instances.
• Structure branch: Pm → Ix → Cp (primitives → interactions → compositions). This is the ANALYSIS path — finding where structural content concentrates.

Dp (dependency) depends only on Pm and feeds into the sublattice computation (which constrains Ps), but in the primitive-level DAG it's an independent branch from Pm.

Depth: Maximum chain: Pm → Ix → Cp (depth 2) or Pm → Lv → Ps (depth 2). Shallow — consistent with the methodology being a relatively flat analytical tool.

Step 5 — Pair Enumeration

C(6,2) = 15 pairs.

Step 6 — Load Classification

Heavy pairs

Moderate pairs

Light pairs

7 heavy pairs of 15 (47%). Moderate integration — appropriate for an analytical tool whose parts are semi-independent (you can do pair analysis without positioning, or position without composition).

Step 7 — Coherent Sub-lattice

Dependency constraints

Pm must be present. Given Pm:

• Lv needs Pm only
• Dp needs Pm only
• Ix needs Pm only
• Cp needs Ix (which needs Pm)
• Ps needs Pm + Lv

Enumeration

Valid subsets of {Lv, Dp, Ix, Cp, Ps} given Pm always present:

Invalid:

• Any subset with Ps but not Lv → INVALID (Ps needs Lv)
• Any subset with Cp but not Ix → INVALID (Cp needs Ix)

Total: 19 valid subsets + {} + {Pm alone} = let me recount. Including {} and {Pm}:

• {}: 1
• {Pm}: 1
• {Pm} + 19 valid subsets of {Lv,Dp,Ix,Cp,Ps}: wait, let me recount the 19.

Actually, let me systematically enumerate. 5 primitives besides Pm, so 2^5 = 32 subsets. Constraints: Ps requires Lv, Cp requires Ix.

Invalid if Ps present and Lv absent: subsets with Ps, no Lv. That's 2^3 = 8 subsets (Dp, Ix, Cp can be anything). Invalid if Cp present and Ix absent: subsets with Cp, no Ix. That's 2^3 = 8 subsets (Lv, Dp, Ps can be anything). Double-counted: subsets with both Ps no Lv AND Cp no Ix: 2^1 = 2 subsets (Dp can be anything).

Invalid: 8 + 8 - 2 = 14. Valid: 32 - 14 = 18.

Total including {} and {Pm alone}: 18 + 1 (empty) + ... wait, the 18 already includes {} (the empty subset of {Lv,Dp,Ix,Cp,Ps} is valid).

So total coherent subsets of 2^6 = 64: We have Pm always present → 18 valid subsets. But we also have {} (no primitives at all) and any subset without Pm. Actually no — everything requires Pm.

Hmm, let me redo this properly. The full lattice is 2^6 = 64 (subsets of {Pm, Lv, Dp, Ix, Cp, Ps}).

Valid subsets:

• {}: 1
• {Pm}: 1
• {Pm + valid combo of remaining 5}: we need to count valid subsets of {Lv, Dp, Ix, Cp, Ps} with constraints Ps→Lv, Cp→Ix. That gives 32 - 14 = 18 valid subsets. But the empty subset {} is included in these 18 (and corresponds to {Pm} alone, already counted). So non-empty valid subsets of the remaining 5: 18 - 1 = 17.

Total: 1 ({}) + 1 ({Pm}) + 17 = 19.

Filter: 19/64 = 29.7%.

Hmm, that's looser than typical substrates. The relatively flat dependency structure (two independent branches from Pm, only Cp→Ix and Ps→Lv as constraints) produces a less filtered lattice.

Actually — this is interesting. The methodology's own structural analysis has a ~30% filter, which is between substrate-tight (~12-20%) and surface-loose (~38%). This suggests it's neither purely substrate nor purely surface in character.

Step 8 — Build-up Sequence

Primary path (the order the 12 steps follow)

Step 0→1: {} → {Pm}
  Identify primitives. The domain has structure.

Step 1→2: {Pm} → {Pm, Lv}
  Decompose partial levels. Each primitive has a gradient.
  The 3/3b iteration loop happens here — primitives and levels refine each other.

Step 2→3: {Pm, Lv} → {Pm, Lv, Dp}
  Specify dependencies. Not all combinations are valid.
  The coherent sublattice becomes computable.

Step 3→4: {Pm, Lv, Dp} → {Pm, Lv, Dp, Ix}
  Analyze pairwise interactions. Find where structural content concentrates.
  Heavy/light classification reveals the structural skeleton.

Step 4→5: {Pm, Lv, Dp, Ix} → {Pm, Lv, Dp, Ix, Cp}
  Identify compositions. Find multi-primitive emergent structures.
  Core triad emerges — the composition that defines the domain.

Step 5→6: {Pm, Lv, Dp, Ix, Cp} → {Pm, Lv, Dp, Ix, Cp, Ps}
  Position real systems. Ground the abstract lattice in concrete instances.
  Attractor positions, gaps, and trajectories become visible.

Alternative path (grounding-first)

{Pm} → {Pm, Lv} → {Pm, Lv, Ps} → add Dp → add Ix → add Cp

Position real systems BEFORE doing full structural analysis. This is the landscape-driven approach: survey what exists first (Step 2), then analyze structure. Pragmatic for domains where many instances are readily available. Both paths converge at the full set.

Step 9 — Load-bearing Compositions

Core triad

{Pm, Lv, Ix} — Primitive, Level, Interaction.

"What is structural analysis?" → Identify PRIMITIVES, decompose their LEVELS, and find where INTERACTIONS between them carry structural content.

All three pairs heavy:

• Pm-Lv: the 3/3b iteration loop ✓
• Pm-Ix: pair analysis of primitives ✓
• Lv-Ix: level-dependent interaction intensity ✓ (moderate-to-heavy — some interactions are level-dependent)

Hmm — Lv-Ix was classified as moderate, not heavy. Let me reconsider.

Alternative: {Pm, Lv, Dp} — Primitive, Level, Dependency.

"What is the lattice?" → PRIMITIVES with LEVELS constrained by DEPENDENCIES produce the coherent sublattice.

All three pairs heavy:

• Pm-Lv: the 3/3b loop ✓
• Pm-Dp: dependency ordering ✓
• Lv-Dp: level-dependent constraints ✓

This works better — all three pairs are heavy.

Alternative: {Pm, Ix, Cp} — Primitive, Interaction, Composition.

"What carries emergent structure?" → PRIMITIVES have INTERACTIONS that compose into COMPOSITIONS carrying emergent properties.

All three pairs heavy:

• Pm-Ix: pair analysis ✓
• Ix-Cp: interactions build compositions ✓
• Pm-Cp: moderate (not clearly heavy)

Pm-Cp is moderate — this triad is weaker.

Core triad: {Pm, Lv, Dp}

"What is a structural lattice?" → PRIMITIVES (the dimensions) with LEVELS (the gradients) constrained by DEPENDENCIES (the ordering) produce the coherent sublattice — the space of possible structural configurations.

This captures the SPATIAL aspect of domain analysis — the lattice itself. It corresponds to steps 3, 3b, and 4 — the most foundational steps.

Secondary composition: {Pm, Ix, Cp}

"Where does emergent content live?" → PRIMITIVES have INTERACTIONS (pairs), and heavy interactions COMPOSE into multi-primitive structures carrying irreducible content. The structural skeleton.

This captures the CONTENT aspect of domain analysis — finding where the interesting stuff is. It corresponds to steps 5-6 and 9.

Named compositions

Step 10 — Emergent Properties

Step 11 — Cross-Domain Patterns

11.1 The methodology's own numbers

11.2 What the intermediate filter tells us

The 29.7% filter is looser than substrates but tighter than surfaces. The methodology has some sequential logic (Cp requires Ix, Ps requires Lv) but also substantial independence (Dp, Ix, Lv are all independently available given Pm).

This makes sense: domain analysis is partly sequential (you must identify primitives before analyzing pairs) but also partly modular (dependency analysis and pair analysis are independent of each other). It's an ANALYTICAL PROCESS — more structured than a surface capability but less tightly chained than an information-processing substrate.

11.3 Structural patterns that replicate

Comparing domain analysis to its own analyzed domains:

The methodology's structural patterns replicate in its own self-analysis — consistent with the self-similar finding.

Step 12 — Synthesis

12.1 What domain analysis IS structurally

Domain analysis is a 6-primitive structural analysis process. Its core triad {Pm, Lv, Dp} produces the lattice — the space of possible configurations. Its content skeleton {Pm, Ix, Cp} finds where emergent structure lives. Its grounding path {Lv, Ps} connects abstract analysis to concrete instances.

The two branches from hub Pm:

• Structure branch: Pm → Ix → Cp (find structural content)
• Grounding branch: Pm → Lv → Ps (connect to real systems)

These correspond to the two main values of the methodology: structural understanding (what IS the domain's structure?) and practical positioning (where do real systems SIT?).

12.2 Relationship to graph semantics

Graph semantics {In, Ar, Ty, Ab, Pt, Cv} operates ON THE OUTPUTS of domain analysis {Pm, Lv, Dp, Ix, Cp, Ps}. A completed domain analysis produces an Instance (In) in the graph semantics framework. Multiple instances get connected into Arrangements (Ar), classified by Type (Ty), and abstracted into shared structures (Ab).

The relationship: domain analysis PRODUCES the instances that graph semantics CONSUMES. Domain analysis is the microscope; graph semantics is the telescope.

The edge between them is not a bridge (no bridge primitives — one doesn't realize the other). It's a FEED relationship: domain analysis outputs → graph semantics inputs. This is analogous to how experimental science (producing data) feeds theoretical science (finding patterns in data).

12.3 What feeds back

Graph semantics feeds back to domain analysis through predictions:

• Type classification predicts filter tightness → check when analyzing new domains
• Abstract domains provide role templates → check primitive coverage when analyzing new instances
• Patterns predict expansion factors → check primitive counts at different levels

This feedback is the methodology's self-correction mechanism — it's where Convergence (Cv) operates.

Summary

Referenced by the model

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

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