Three Structural Surfaces, One Store

SERAPH is the only knowledge substrate with three distinct structural surfaces over the same content:

• Embedding field — geometric proximity (cosine similarity). Emergent from content.
• Parent tree — lineage proximity (who parented to whom at ingest time). Emergent from ingest order.
• Typed edges — explicit, user-asserted relations (cites, depends_on, causes, or any domain-specific relation). Declared, not inferred.

The first two are emergent, they fall out of the data. The third is curated, it captures directional, authoritative relations the geometry has no way to assert: citation, causal links, domain-specific structure. Two relations people often expect to live here are handled natively instead, and neither needs a typed edge: contradiction is detected from the emergent geometry (see below), and supersession is a frame-lifecycle status (Superseded, plus redirect frames on consolidation), not an edge. All three surfaces share the same provenance guarantees. Typed-edge mutations are recorded as sentinel frames in the watermark chain, they're as tamper-evident as content commits.

Emergent surfaces: agreement and disagreement.

The embedding field and parent tree can agree, disagree, or partially overlap. SERAPH exposes this through a three-population model:

Population	Meaning
Consensus	Both surfaces agree — tight, well-formed concept zone.
Geometric-only	Cosine-close but lineage-distant — cross-domain analogy candidates.
Lineage-only	Same subtree but cosine-distant — concept drift within a lineage.

The ratios between populations are themselves diagnostic — no other system can compute them because no other system has both emergent surfaces. This is also how SERAPH detects contradiction: a pair that is cosine-close but whose content diverges (geometric or consensus population) is a conflict the geometry surfaces on its own, no edge required. Contradiction is a property of the geometry, read directly off these two surfaces.

Typed edges: structure the geometry can't see.

An embedding can tell you two frames are semantically close. It cannot tell you one cites the other as evidence, that one causes another, or any domain-specific relation you need to author. Those are directional, authoritative claims neither the geometry nor the frame lifecycle expresses. Typed edges capture them. (Contradiction and supersession are different — contradiction SERAPH detects geometrically, and supersession is carried by frame status. A typed contradicts or supersedes edge is only for recording a curated, adjudicated assertion on top of those native mechanisms, never the primary way SERAPH knows.) Typed edges are:

• Append-only and auditable. Assertions and retractions are logged as sentinel frames — never mutated, always replayable.
• Structurally isolated. Typed edges never affect in-degree, eigenframe promotion, or similarity scoring. The emergent geometry stays pure.
• Composable with search. structural_expand chains typed-edge traversal with similarity queries — "find everything this frame cites, then expand semantically from those targets" is a single operation.
• Bidirectional when declared. A cites relation can auto-insert the reverse cited_by edge at assert time.

A vector database gives you geometric proximity. A knowledge graph gives you authored structure. SERAPH gives you both — plus their interaction — in one file, with one provenance chain.

Declaring and Following Structure

Custom relationship declaration. Applications may declare any relationships their domain requires, such as implements, supersedes, supports, refutes, derived-from, depends-on, authored-by, classified-as, or paired-with. Relationships may be unidirectional or bidirectional, weighted, and subject to retraction (with the retraction itself recorded, not silently applied).

Relationship traversal. Queries may walk forward or backward along any declared relationship, filter by relationship type, and combine multiple relationships in a single query. Because relationships are recorded using the same append-only, ordered, tamper-evident mechanism as content, every traversal is reproducible and auditable.

Composition of similarity and structure. Because all three traversal operations share the same geometry, they compose directly within a single query rather than across separate systems with their own consistency assumptions. Examples of the resulting pipelines:

• Find content similar to this query, follow the IMPLEMENTS relationship, and return the resulting items ranked by their fit to the original query.
• Beginning from this item, follow REFUTES one step, then find everything similar to those refutations.
• From this claim, follow DERIVED-FROM back to its sources and surface any source that has since been SUPERSEDED.

Each step is declarative, deterministic, and composable. The pipelines are the queries. Pipelines that bridge distant regions of the store, where the connecting content has no shared ancestry, are not a degraded special case: the chains produced by composed similarity walks across such regions exhibit gradient coherence comparable to chains drawn from within a single lineage. Cross-region reasoning is a first-class substrate capability, not a fallback.

Two Layers, One Substrate

The role of each layer is most clearly seen in the following comparison.

	Emergent layer	Declared layer
Built by	Automatically, at the moment content arrives	Declared by the application or operator
Used for	Discovery, similarity, neighborhoods, steering	Precise queries, compliance walks, deterministic pipelines
Strengths	Captures meaning the way users actually engage with it; requires no schema	Captures the exact structure a domain requires; explicit and auditable
Independence	Cannot be polluted by declared edges	Cannot distort the underlying geometry
Composes with the other	Yes, within a single query	Yes, within a single query
Modality	Whatever the encoder operates on	Independent of modality

This architectural decision broadens SERAPH's applicability. Designers are no longer forced to choose between an intuitive memory and an explicit memory. The intuitive substrate handles similarity. The explicit overlay handles those parts of the system where exactness is essential. Both reside in the same file, are queried together, and are verified together.