The Hierarchy DAG¶
A Type System for Prerequisite Relations Between Primes¶
Companion to Structural and Framed Primes (which justifies the decompose edge type), The Calculus of Abstraction (which positions the lexicon/grammar pairing), and the experimental record from the 28 review rounds R1–R21 + E1–E7 that produced the 912 directed edges and 3 mutual pairs the paper formalizes.
Abstract¶
A catalog of prime abstractions is a set of nouns. To do real work, the nouns must be related — but is-related-to is underspecified, and managing cross-domain reasoning with a single edge type produces a brittle, undifferentiated mess. This paper formalizes the relational type system that emerged from 28 rounds of curation in the Encyclopedia of Abstractions, in which ~920 directed prerequisite edges were proposed, reviewed, committed, and (in many cases) revised. The system has four edge types — subsumption (kind-of), composition (built-from / presupposes, with two flavors), decompose (framed-applied to structural-core), and mutual (bidirectional, outside the acyclic topology) — one metadata attribute (the qualifier field: strict / typical / conditional), and two node classes (primes and connectors, the latter for composite-under-a-gloss bundles on a separate aspect_of edge layer). The system was not designed from first principles; it emerged from disciplined wiring, each refinement traceable to a specific failure mode (subsumption alone insufficient for feedback vs damping; composition alone couldn't name what signaling does to information_asymmetry; the connector layer exists because justice is real and useful but not a single structural pattern). The paper documents the system as it stands and what it enables — search moderation, curriculum tiering, faithfulness auditing, and a legible DAG visualization.
1. Introduction: Why type the edges?¶
A prime abstraction, in this project, is a recurring structural pattern that travels across at least three domains of human knowledge. The Encyclopedia of Abstractions is the corpus of such primes — at present 643 of them, with another 27 minted during the work this paper formalizes. A corpus of 643 primes is a vocabulary. It is not, by itself, a structured body of knowledge. To make it one, the primes must be related — placed in some arrangement that reflects which patterns presuppose which others, which are specializations of which, which name the structural core that other primes are applied versions of.
The most permissive way to relate the primes would be is-related-to: an undirected, untyped, multi-graph relation that records the existence of a connection without saying anything about its character. This is what concept maps, knowledge graphs in their crudest form, and most early curation efforts in the project itself produced. The trouble is that is-related-to is uniformly informative no matter what relation it stands for. The connection between feedback and damping is not the same as the connection between feedback and homeostasis, which is not the same as the connection between feedback and circular_causality. The first is composition (damping presupposes feedback as one of its mechanisms); the second is decompose (homeostasis is the framed-applied form of feedback); the third is something like sameness-at-different-altitude (circular_causality is so close to feedback that the M-bucket audit flagged them for dedup). Collapsing all three into is-related-to loses everything that would let a downstream tool — a curriculum sequencer, a search filter, a visualization — do something useful with the corpus structure.
This paper develops the typed alternative. It documents the four edge types, the one metadata attribute, the two node classes, and the acyclicity discipline that emerged from twenty-eight rounds of review work in the project's Phase-06 prerequisite-edges sub-project. The system is fitted to the corpus: each type and each refinement of the type system was added because the work hit a case it could not handle with what was already on hand. Where this paper presents the system as if it were designed, the honest history is that it was discovered — the type system is what twenty-eight rounds of attention left behind once the brittle alternatives had failed.
The paper proceeds as follows. Section 2 establishes the four edge types, with worked examples and the failure cases that motivated each. Section 3 introduces the qualifier metadata attribute and the reasoning that placed it outside the type hierarchy. Section 4 distinguishes the two node classes (primes versus connectors). Section 5 articulates the acyclicity discipline and its one principled exception. Section 6 documents the edge lifecycle — the statuses that record how each edge's confidence has moved over time — and the four-reviewer pipeline that produced them. Section 7 discusses what the type system makes possible for downstream tooling. Section 8 relates the system to two companion conceptual essays. Section 9 concludes with a deliberate note on what the system does not do, which is constrain meaning at runtime — it scaffolds curation discipline, and that is a smaller, more honest claim than a "formal type ontology" might suggest.
2. The four edge types¶
A directed edge A → B in the hierarchy DAG says that B is the more foundational concept and A depends on B. The choice of "depends on B" rather than the reverse is a convention forced by the practice of curriculum design: when reasoning forward, one usually wants to know what one must understand first, which is the parent (B) in this convention. A reader who works backward, from a leaf, encounters the dependencies in the order they need to be picked up.
The convention is necessary because the four edge types relate parent and child differently. Conflating them under a single arrow loses precisely the structural information the types were introduced to carry. The four types are subsumption, composition, decompose, and mutual.
2.1 Subsumption: A is a kind of B
A subsumption edge A → B says that A is a species of the genus B — the relation of taxonomic inheritance. Damping and amplification are kinds of feedback-affecting-process; analogy and simile are kinds of comparison; cognitive_appraisal and revisionism are kinds of interpretation. The species adds differentia to the genus: damping is feedback that opposes amplitude change, amplification is feedback that grows it. The genus admits the species as a special case without losing its general character.
Subsumption is the type of relation that classical taxonomy depends on. It is what makes Linnean biology work, what scientific classification in chemistry and physics relies on, and what most introductory pedagogy assumes when it teaches first the general, then the specific. In the corpus, subsumption is the second-most-common edge type (roughly 31% of post-audit live edges) and is concentrated in places where a single umbrella prime parents many specific patterns — representation parents fourteen children by subsumption and composition combined; learning parents ten; pedagogy and authority parent seven each. These are the hub roles in the corpus, and subsumption is the relation that gives them their hub character.
Subsumption alone proved insufficient very early in the project. The case that broke it was signaling → information_asymmetry. Signaling is not a kind of information asymmetry; it is what an agent does in response to information asymmetry. A subsumption edge would have mis-placed signaling under the asymmetry it presupposes. The relation needed a different type — and that type was composition.
2.2 Composition: A is built from / presupposes B (with two flavors)
A composition edge A → B says that A's existence or operation depends on B's, but A is not a kind of B. Composition admits two flavors that the curation work found genuinely distinct enough to label separately.
The first flavor is part_of: B is a constituent of A. The relation iconography → symbolic_representation (part_of) says that iconography is made up of symbolic-representation moves — the symbolic vocabulary is a component out of which iconographic systems are assembled. The relation loss_aversion → preference originally seemed part_of (loss-aversion is a component of preference structure), though the later re-poll revised it to presupposes.
The second flavor is presupposes: B must already obtain for A to apply, but B is not itself part of A's internal structure. The canonical example is signaling → information_asymmetry (presupposes). Signaling presupposes information asymmetry — without an asymmetry, there is nothing to signal about — but the asymmetry is not a piece of signaling. It is the precondition that makes signaling meaningful. Other clean cases: transaction_costs → exchange (transaction costs presuppose exchange as their substrate); coordination → dependency (coordination presupposes dependency among the actors who are coordinating); traceability → transformation (the trace presupposes the transformations being traced).
The part_of / presupposes distinction matters because it answers different downstream questions. When the curriculum sequencer asks "what must I teach first?", it is asking about presupposes: the prerequisite that must already obtain. When the search engine asks "what concepts are inside this one?", it is asking about part_of: the constituents that decomposition would reveal. Conflating them at the edge level forces the downstream tool to re-derive the distinction at query time, often from prose alone.
Composition (combined across both flavors) is the most common edge type in the corpus — roughly 42% of post-audit live edges. Its prevalence is not an artifact of permissiveness. The long-tail review work (R18–R20) repeatedly found that subsumption was the wrong default when the corpus stretched into the structural-dynamics flavor: the child orphan was usually a manifestation, failure mode, driver, or use case of the parent, not a kind of the parent. The empirical pattern was strong enough that we built a v1→v2 type-correction loop into the review pipeline — dispatching one reviewer first to surface the type-mismatches before sending the cleaner packet to the others.
2.3 Decompose: A is the framed-applied form, B is the structural core
A decompose edge A → B says that A is a framed or applied version of the more structural concept B — A retains the relational pattern of B but is wearing the institutional, normative, or domain-specific vocabulary of its home discipline. The relation is justified at length in the companion paper structural-and-framed-primes.md, which develops the structural/framed distinction and the decomposition operation that connects a framed prime to its structural core.
Worked examples: procedural_fairness_due_process → impartiality (decompose) says that due process is the institutional-legal application of the more general structural pattern of impartial review, which itself recurs across peer review, judicial appeal, contractor bid evaluation, and arbitration. The legal frame travels with procedural_fairness_due_process; impartiality is what is left when the legal frame is stripped away. Similarly, narrative_construction_in_history → narrative (decompose), revisionism → interpretation (decompose), microhistory_vs_macrohistory → scale (decompose).
Decompose is the rarest of the three structural types in the corpus, at roughly 4% of post-audit live edges. The scarcity is intentional. The companion paper argues that decompose is the relation that exposes a framed prime's structural skeleton, and the skeleton is often already named as its own prime — impartiality, narrative, interpretation, scale. A clean decompose edge converts a framed-prime-only application into something a curriculum or search engine can recognize across domains where the original framed prime would have looked alien. It is the relation that makes cross-domain transfer of framed primes structurally legible.
Where decompose proved confusable was the boundary with composition/presupposes. A clean check: a framed prime decomposes to a structural prime when stripping the frame leaves the structural pattern intact; a prime presupposes another when removing the other leaves the original meaningless. Due process decomposed to impartial review retains its analytical work in the new (non-legal) domain. Signaling with information asymmetry removed retains nothing — the relation is presupposes, not decompose.
2.4 Mutual: A and B are co-defining, neither is structurally prior
The first three edge types are directed. The fourth is bidirectional, and it sits outside the acyclic topology that the rest of the DAG maintains. A mutual edge A ↔ B says that A and B are co-defining — neither is more foundational than the other, and any attempt to make one a parent of the other generates a relation neither concept can fully support.
The canonical case is symmetry ↔ asymmetry. Each is defined relative to the other: symmetry is invariance under transformation, asymmetry is directed imbalance, and neither concept is meaningful without the contrast the other provides. Attempting asymmetry → symmetry (asymmetry presupposes symmetry as the baseline against which it deviates) is plausible until one considers that symmetry is itself defined by which transformations leave the structure invariant — which itself presupposes the existence of asymmetric counterparts that do not leave it invariant. The two concepts are knot, and the cleanest representation is to admit they are knotted.
The corpus has three mutual pairs: symmetry ↔ asymmetry (R10), informal_enforcement ↔ social_norms (R1), and incentive_compatibility ↔ mechanism_design (R5). All three were committed deliberately, after the reviewers tried both directed alternatives and found each one to leak structure the other side actually had.
Mutual edges are out of acyclic topology. They are recorded in the ledger, but excluded from the directed-DAG computations that the rest of the system runs (curriculum tiering, ancestor-set computation, cycle checking). This exclusion is not a hack — it is the principled treatment of relations that genuinely violate the directed-acyclic assumption the rest of the system depends on. The cost of admitting them is that any tool downstream must make a choice about whether to follow a mutual edge in either direction, or neither; the benefit is that the corpus does not have to lie about co-defining concepts that resist hierarchical placement.
The project considered a fourth mutual pair in R21 — representation ↔ interpretation, the encoding/decoding dyad — and rejected it on the grounds that representation can persist without active interpretation (cave paintings, dead languages remain representations no one is currently reading), but interpretation cannot exist without a representational substrate to operate on. The dependence is one-way. R21 committed interpretation → representation (composition/presupposes) rather than a mutual pair. The decision matters: it sets the bar for mutuality at genuine co-definition, not at strong mutual relevance.
2.5 Why these four, and only these four
The history of the project suggests a fifth type was nearly added at three different points. The first proposal was a co_requisite type for cases where two concepts must both be present but neither presupposes the other; the project decided this was just bidirectional presupposes, which is what mutual already names. The second was a qualified_presupposes type for cases where the prerequisite is typically but not strictly required; the project decided this was metadata on composition, not a new type, and added the qualifier field instead (Section 3 below). The third was a dual or complement type for opposite poles of a duality; the project decided this collapsed too cleanly into mutual for the most genuinely-co-defining cases (symmetry/asymmetry) and into composition/presupposes for the cases where one pole is structurally prior (reversibility/irreversibility after the bundled-prime split). In each case the discipline was to ask whether the existing type system could carry the work, and the answer turned out to be yes.
Four types appear to be enough. They are not minimal — subsumption could in principle be expressed as a special case of composition/part_of in which the parts happen to be category-defining — but the practical cost of the conflation outweighs the theoretical economy. Subsumption answers "what kind?"; composition answers "what is presupposed?"; decompose answers "what is the structural skeleton inside the frame?"; mutual answers "what is the co-defining pair?". Each question is one the corpus must answer, and conflating them would force the downstream tooling to disambiguate at query time. The type system pays its rent.
3. The qualifier metadata attribute¶
After the long-tail review work in R17c, a structural pattern emerged that the four-type system did not quite carry. Several composition/presupposes edges were being committed under reviewer disagreement of the form: "X usually involves Y, but X can occur without Y in some forms." Damping → feedback was the original case: most damping in real systems involves a feedback mechanism, but pure dissipation (friction in a sliding block, viscosity in a flow) can damp without anything resembling a control loop. Public_goods → social_dilemma was similar: public goods commonly generate dilemmas in provision, but their defining properties (non-excludability and non-rivalry) do not strictly require a dilemma. The reviewer who insisted on strict presupposes was being honest about the structural relation; the reviewer who insisted on the typical case was being honest about the empirical pattern. Both were right, and neither was captured by a binary presupposes / not-presupposes distinction.
The temptation was to add a new edge type: presupposes_strict versus presupposes_typical. We rejected the new type, for two reasons. First, it would have forced every existing composition/presupposes edge to be retroactively labeled as one or the other — a corpus-wide reclassification of hundreds of edges, most of which were straightforwardly strict and gained nothing from the new label. Second, the project had already settled on a policy of not multiplying types when the work could be carried by a smaller addition. The smaller addition is metadata: an optional qualifier field on the edge record, with three values.
strict(the default if the field is absent): B must obtain for A to apply. This is the standard presupposes semantics.typical: B commonly obtains, A typically involves it, but A can occur with other mechanisms. The relation is real but not necessary.conditional: A presupposes B under some specified condition (recorded in the edge's note field), and not otherwise.
The field defaults to absent, which means strict by convention — this is the existing semantics of the roughly 880 edges committed before E6, and they did not need to be relabeled. Nine edges from R17c received the typical qualifier in the E6 round; one more was added in E7 (symmetry_breaking → tipping_points_or_phase_transitions, marked typical because continuous symmetry breaking exists without a discrete tipping point). The number is small. The point is not the volume; the point is that the type system grew a graded shading without proliferating types.
The qualifier field also relates to a deeper observation about the corpus: many presupposes relations are themselves degree-bearing. The strict/typical distinction is the first cut at making the degree explicit. We anticipate downstream uses — visualization styling, curriculum hedging, faithfulness auditing — will draw on the qualifier to communicate uncertainty to readers without needing to descend into the edge's prose note. A typical-qualifier edge in a curriculum sequence becomes "you usually want to understand B before A, but you can in some cases skip it" rather than "B is required reading"; in a visualization, the edge becomes a dashed line rather than a solid one. The metadata is small; its downstream uses are not.
4. Node classes: primes versus connectors¶
Most of the nodes in the hierarchy DAG are primes. A few are not. The corpus distinguishes two node classes, and the type system records the distinction explicitly.
A prime captures a single recurring structural pattern, defined independently of any one domain. Feedback, equilibrium, signaling, lock_in, criticality — each names one relational pattern, with one structural signature, and the curation question for a prime is whether it cleanly does the work of one abstraction.
A connector is a composite-under-a-gloss: a node that bundles two or more distinct structural patterns under a single applied framing. Justice is the canonical example. To call something just is to bring in equity (proportional allocation), impartiality (procedural neutrality), desert (recipients deserving), due process (legal protections), and often equality before the law. These are five distinct structural patterns, each itself a prime; justice is the connector that bundles them under a normative gloss. The bundle is real and useful — it picks out the cluster of patterns we deploy when we make moral evaluations of social arrangements — but it is not a single relational pattern in the way feedback is.
The corpus has one connector at present (justice) and three more in the deferred pipeline (vortalith from the long-tail triage; causal_layered_analysis_cla and failure_mode_and_effects_analysis_fmea from the M/G/C audit, both named methodologies that bundle decomposition + verification + prioritization under a single procedural framing). The connector classification is conservative: the bar for promoting a node from prime to connector is high, and the corpus deliberately holds many edge cases as primes that could be argued to be bundles.
Connectors live on a separate edge layer. The primary DAG carries the four edge types (subsumption, composition, decompose, mutual) between primes; connectors participate via a fifth relation, aspect_of, recorded in a separate connector_edges.jsonl file. Equity → justice is an aspect_of edge: equity is one of the structural aspects that justice as a connector points at. The aspect_of layer never supersedes a prereq edge; it is additive, supplying the connector-bundle relations without polluting the prerequisite topology that the curriculum and search tools depend on.
The connector layer matters for downstream tooling for the same reason the qualifier field matters: it allows the corpus to record a real and useful kind of relation without forcing the primary type system to absorb it. Search moderation in particular benefits from the layer: a query like justice legitimately returns the connector node, but a query like what is the foundational structural pattern for X? returns only primes, never connectors. The layer is also what keeps connector ≠ hub ≠ category clean. A hub is a prime with many subsumption or composition children; a category is a curation grouping for browse pages; a connector is a node-class distinct from primes in what it does relationally. The three were repeatedly confused in early curation work; the explicit layering is what allowed the project to recover.
5. The acyclicity discipline and its one principled exception¶
The hierarchy DAG is acyclic. This is the most important structural constraint in the system, and it is enforced after every commit by the build-provenance pipeline. Cycles would break the topological ordering that the curriculum sequencer depends on, the ancestor-set computation that feeds altitude scoring, and the visualization layout that the website renders. Twenty-eight rounds of review work produced exactly zero cycles in the committed live edges — the discipline held throughout.
The discipline did not hold without effort. Five of the long-tail review rounds (R17b/c, R18, R19, R20) generated proposals that would have introduced cycles, and each had to be broken before commit. The breakages followed a single principle: when a cycle was detected between two proposed edges, drop the non-primary direction (the one not marked as the orphan's primary candidate in the long-tail triage), keep the primary, log both for revisit. The R18 cycle resolution log captured seven such drops, including the fault_tolerance ↔ fail_safe near-cycle and the threshold ↔ tipping_points_or_phase_transitions cycle that R20 review later confirmed should remain broken in the direction R18 chose.
The one principled exception to acyclicity is the mutual edge type (Section 2.4). Mutual pairs are recorded in the ledger but excluded from the directed-DAG computations. The three mutual pairs (symmetry ↔ asymmetry, informal_enforcement ↔ social_norms, incentive_compatibility ↔ mechanism_design) live in the ledger but do not appear in the topological sort, do not contribute to ancestor sets, and do not propagate altitude. They appear in the visualization as bidirectional edges with distinctive styling, and they appear in search as bidirectional cross-references. They do not break the acyclicity guarantee because they are explicitly out-of-topo.
The system also recognizes genuine roots — nodes that are intentionally parentless. A genuine root is a prime that is foundational enough that no other prime is structurally more basic; the corpus would be falsified if such a prime were placed under a parent. The R-audit in Phase 1 surfaced 45 long-tail genuine roots (including coupling, flow, gradient, recursion, second_law_of_thermodynamics, wave), and 73 of the in-graph nodes from the dense-cluster work are also genuine roots by structural placement. A genuine_roots.json file records the audited list, and downstream tooling consults it to not flag these primes as "missing parent." The total is 118 genuine roots, which is roughly 18% of the corpus.
The combination — acyclic directed primary topology + mutual pairs as out-of-topo exceptions + explicit genuine roots — gives the corpus a structure that is both formally well-behaved and faithful to the relations the work actually found. Multi-parent edges are permitted (a child can have more than one parent), and the corpus has 69 multi-parented children at the time of writing, with several nodes having three parents (value_commensuration, risk_aversion, cognitive_appraisal, sensemaking, social_capital, indifference_curves). Multi-parenting was the right relaxation: the corpus genuinely has children that legitimately inherit from multiple parents, and forcing them to single-parent would have introduced false structural choices.
6. Edge lifecycle: statuses and provenance¶
The type system records what an edge is. The status system records how confident the project is in that edge — and how that confidence has changed over twenty-eight rounds of review. Every edge in the ledger carries one of seven statuses.
commit: the edge is live, the review converged, no caveats remain. This is by far the most common status: 1078 of 1133 edges in the consolidated provenance carrycommit.retype: the edge is live, the parent and direction are unchanged, but the type was revised after the initial commit. Six edges carry retype, all from the R17b risk_aversion catch onward.provisional: the edge is live, but at least one reviewer dissented in a way the project chose to log rather than drop. Nine edges remain provisional at the time of writing, mostly cross-flagged with E4 SPLIT/MERGE pending the merge procedure.held: the edge is not live. Held edges are deferred to a later decision point — usually because the right answer turned out to depend on a separate decision (the bundled-prime split heuristic, the merge procedure). Three edges currently held.superseded: the edge was once live but a later round committed something that replaced it. Seven edges superseded, often from re-poll-control catches.drop: the edge was rejected outright. Thirty-two edges dropped over the project's run.mutual: out-of-topo bidirectional, per Section 2.4. Three edges.
These statuses are not just bookkeeping — they constitute the edge lifecycle. An edge typically enters the ledger as a proposal from a curator or model; it survives review to become commit or provisional; it may later become retype if a re-poll catches a type error, superseded if a later round commits a better version, or drop if the structural argument finally falls apart. The status history is preserved per-edge in hierarchy_provenance.jsonl, which carries the proposer rationale, the curator's note, and every model verdict ever recorded on the edge.
The status system existed because the project used a re-poll discipline: every review packet hid four control edges drawn from earlier rounds, mixed into the new proposals. A committed edge that failed its control was downgraded; the discipline produced real catches (R17b risk_aversion → preference was a subsumption commit that the R17b fresh-context re-poll discovered should have been composition/presupposes). The four-reviewer pipeline (one Claude subagent, Gemini, ChatGPT, and the curator) produced enough independent signal that single-reviewer dissents could be sensibly accommodated as provisional rather than forcing a binary commit/drop choice.
The lifecycle matters for the type system because edges change types over time. A subsumption commit can become a composition/presupposes retype when a later re-poll catches the mistype. A composition commit can pick up a qualifier=typical field in a later round. A held edge can be promoted to commit when the merge procedure resolves the blocking question. The statuses make the changes legible: the ledger is not a snapshot of the project's current beliefs but the full history of how those beliefs evolved.
7. What the type system enables¶
The four-types-plus-qualifier-plus-connectors-plus-acyclic-with-mutual-exception system was assembled to do real downstream work. Several of the downstream tools depend on the distinctions:
Search moderation. A query like what is the foundational structural pattern for X? can be answered by following composition/presupposes edges to roots; a query like what kinds of X exist? can be answered by following subsumption edges downward; a query like what is the structural skeleton of this framed concept? can be answered by following the decompose edge. The connector layer ensures that connectors like justice are returned for queries about the concept but not for queries about foundational structural patterns.
Curriculum tiering. A topological sort over composition/presupposes and decompose edges produces an altitude scalar for each prime — a measure of how far from the roots that prime sits. Genuine roots have altitude 0; primes one composition-hop down have altitude 1; and so on. The altitude scalar feeds curriculum sequencing: a learning path through the corpus respects altitude, introducing presupposed concepts before the concepts that presuppose them. Subsumption edges produce a separate sense of altitude — taxonomic depth from the most general category to the most specific — which a different curriculum tool can use for breadth-of-coverage planning.
Visualization. The DAG visualization renders subsumption edges in one style (taxonomic inheritance, perhaps blue), composition edges in another (built-from / presupposes, perhaps orange), decompose edges in a third (framed-to-structural-core, perhaps purple), mutual edges in a fourth (bidirectional, perhaps green). The qualifier field can drive line style (dashed for typical, solid for strict). The connector layer can be toggled on or off. The acyclicity guarantee lets the layout use any standard hierarchical-DAG algorithm without worrying about cycles, and the genuine-roots list lets the layout collect parentless primes into a clean side region rather than scatter them.
Faithfulness auditing. When the project's reasoning pipeline (the AAR sequence in calculus-of-abstraction.md) produces a trace, the trace can be checked against the DAG: does it follow real prerequisite edges, or does it invoke a prime in a position where the DAG says it should be presupposed? The type system makes the check tractable. Faithfulness audits in the project's R20 review caught several such mismatches, including the damping/amplification cases where a proposed presupposes edge was actually a typical relation that the proposer had committed as strict.
The system also enables several things the project has not yet built but anticipates building: a v1↔v2 drift detector that uses the typed edges to spot when a prime's v2 has narrowed to the point that its existing edges no longer hold (Section 9 of structural-and-framed-primes.md); a search-engine query expander that follows edges by type-specific weights; a curriculum sequencer that respects the qualifier field; a visual interactive tool for editing edges with their types preserved through the UI.
8. Relation to the companion essays¶
This paper is the third in a series of three short conceptual papers describing different layers of the Encyclopedia of Abstractions.
Structural and Framed Primes develops the typology of how primes travel across domains: structural primes (relational patterns with no residual frame) versus framed primes (patterns whose meaning is partly constituted by an interpretive context). That paper is upstream of this one. The decompose edge type in Section 2.3 above exists to record the structural-to-framed relationships the structural/framed paper identifies as the central typology. Without the structural/framed distinction, decompose has no work to do; without the decompose edge type, the structural/framed distinction has no place to live in the DAG.
The Calculus of Abstraction positions the project's pairing of primes (the lexicon) and operations (the grammar). The DAG is the substrate over which several of the grammar's operations run. Lift (move from a domain-specific case to a more abstract pattern) follows composition and decompose edges upward; lower (move from an abstract pattern to a domain-specific instance) follows them downward. Match and transport (apply a pattern from one domain to another) depend on subsumption and decompose to find structural analogues across the corpus. The type system documented in this paper is what makes the verbs typed — what determines which verb can be applied to which kind of edge, and what the result will be.
Read together, the three papers describe three related layers: structural/framed paper provides the typology, calculus paper provides the grammar of operations, and this paper provides the typed substrate on which the operations execute. Each paper can be read alone, but the project's full story requires all three.
9. Conclusion: a discipline, not a metaphysics¶
This paper has presented the relational type system of the hierarchy DAG as if it were a coherent design. The honest history is that it emerged from twenty-eight rounds of curation work, with each refinement of the system traceable to a specific case the system as it stood could not handle. The four types, the qualifier metadata, the two node classes, the acyclicity discipline with its mutual exception, the seven-status edge lifecycle — none of these were planned in advance. All of them were what the work left behind once the brittler alternatives had failed.
This origin story matters because it sets the right expectations for what the system does and does not do. The type system does impose a discipline on curation work: it forces every edge proposal to commit to a specific type, to identify the type if the type is wrong, and to follow a re-poll discipline that catches mistypes after the fact. The discipline is enforceable, auditable, and (the project has now shown) tractable at the corpus scale.
The type system does not impose a metaphysics on the underlying relations between concepts. The four edge types are useful categories for organizing curatorial decisions; they are not claims about the deep nature of conceptual dependency. There are surely relations between primes that the system does not cleanly carry — the qualifier field is one place where the project hedged rather than committed to a sharper distinction; the structural/framed and the connector categories are others. The system is fitted to the curation work it grew out of, and it is honest about being so. A reader expecting a formal type ontology in the philosophical sense — with eliminativity claims, soundness proofs, and a clean account of what every possible relation between primes must be — will be disappointed. A reader who wants to understand what discipline the corpus has imposed on itself, and what that discipline now enables for downstream tooling, will find the system pays its rent.
The system is also still evolving. The bundled-prime audit (E4) surfaced eight _and_ compounds that should be split into separate primes; the v1↔v2 drift audit (E7) found that 18% of dual-version primes had narrowed in v2 in ways that could break existing edges; the long-tail review work continues to expose places where a fifth edge type might be argued for and rejected, where a new node class might be entertained and declined. The discipline is to keep the system small enough to be tractable while admitting refinements when the work makes a real case for them. The corpus and its type system are a record of what twenty-eight rounds of disciplined attention produced. The discipline continues.
Acknowledgments and provenance. The four-edge-type system was first proposed in the project-06b plan (2026-05-26) and refined through review rounds R1-R21 + E1-E7 (2026-05-26 through 2026-05-28). The qualifier metadata field was added in round E6 after R17c surfaced the qualified-presupposes pattern. The connector node class was introduced in round R3 with the justice connector as the first instance. The genuine-roots registry was added in Phase 1 Step 5 (2026-05-28). All edge proposals, model verdicts, curator decisions, and disposition notes are preserved in an internal provenance ledger; the full project log is kept as internal documentation. The companion essays are conceptual/structural-and-framed-primes.md and conceptual/calculus-of-abstraction.md.