Chapter 9. The Mismatches

RDF is painfully simplistic, but it allows you to work with real-world data and problems that are horribly complicated.

— Dan Brickley and Libby Miller, foreword to Validating RDF Data

Chapter 8 put both halves of the argument into theorem form: every application has the derived form, and the deployed standards fill it. That invites suspicion — a derivation that lands exactly on a deployed stack looks retrofitted until its mismatches are on the table. This chapter puts them there. The fit is not exact. There are two mismatches between the model Part II forced and the standard Part III named, and two more between the standard and the platform that ships it — the browser. Each is located; the first two are measured (Props. 9.1–9.2), and one of them is turned into a prediction the standard later honored. Part IV holds everyone else’s models to the same test.

Mismatch one: the unnamed entities

RDF permits facts about entities with no name — blank nodes. Nothing in Chapter 5 forced them: the derivation minted a fresh URI wherever it needed an entity, because minting a fresh URI costs nothing. So blank nodes are surplus, and the surplus has a precise reading. A graph containing _:b asserts that something exists with these properties; RDF’s own semantics says exactly this — simple entailment treats blank nodes as existential variables. The extension is well-motivated. Entities routinely exist before anyone names them: every form not yet submitted, every observation not yet reconciled, describes a something. So a model that forbade the unnamed would fail R1 at the margins of every domain.

Now the cost, and it can be stated exactly; write ⊕ for the merge of two states.

Prop. 9.1. Over ground facts, merge is plain set union — ⊕ = ∪ — and Chapter 5’s four merge laws hold on the nose: totality, order-freedom, idempotence, atomicity (B-2a–d). With blank nodes, idempotence and atomicity hold up to logical equivalence — and only up to logical equivalence.

Proof — merging a graph with itself doubles the existentials: equivalence survives, identity does not.

Blank nodes are scoped to their graph, so composition must standardize them apart: s ⊕ s carries two copies of each existential. The result asserts nothing new — it entails s and is entailed by it — so s ⊕ s ≡ s. But as a set of atoms it is strictly larger, so s ⊕ s ≠ s. B-2c survives semantically and fails syntactically. Atomicity bends the same way: an atom containing a blank node means something only together with the atoms sharing its variable, so self-containedness holds per connected component, no longer per atom. Restoring identity from equivalence costs exactly two computations: canonical labeling — standardized in 2024 as RDFC-1.0, deterministic, with adversarial worst cases the spec itself documents — and redundancy elimination, which is coNP-complete in general. ∎

That is the bill for anonymity, and it falls exactly on the party that chose anonymity. Name your entities and state composes by set arithmetic. Leave them unnamed and composition becomes theorem-proving in miniature, landing precisely at the seam where Chapter 6 put canon. The web’s grain shows through the formalism: the work appears exactly where names are missing. The deployed stack’s own list idiom shows the cost: an ordered collection encoded as a chain of unnamed cells carries the cost of anonymity at every link. Order is the recurring case. State it as facts — a rank fact per member, Chapter 3’s lead story — and it merges like facts. Fold it into shape and it costs what shape costs.

Mismatch two: the fourth position

The web demands one requirement Chapter 5 never imposed. R1–R3 govern facts about the world; the web also traffics in claims — the same fact asserted by one source and disputed by another, provenance, retraction, trust. Call it R4:

R4 — Attribution. Facts about who asserts facts.

Prop. 9.2. The arity-minimal state model satisfying R1–R4 is 𝒫(I × Fact) — quads.

Proof — set union forgets who contributed; reification attributes only descriptions; one position repairs it.

Union erases contribution: B-2d says atoms(s ⊕ s′) = atoms(s) ∪ atoms(s′), and a set union keeps no record of which side an element came from. So within 𝒫(Fact), “who asserted this atom” is unrecoverable by construction — attribution lives in the history of the state, and states-not-histories is what B-2c chose. Reification — the standard’s device of describing a fact in triples of its own — does not escape either: it attributes only a description of the fact. The described fact is then either also present as a plain atom or absent. If present, it is asserted outright and the attribution is defeated. If absent, it is attributed but never stated — quoted rather than asserted. The minimal repair types the atom as a pair (source, fact). The source position must refer across parties, hence lies in I — R3’s argument (condition B-3 in Appendix B) verbatim. One extra position suffices, because attribution of attributions is more quads, not more positions. Rerun B.1–B.3 over the retyped atom: 𝒫(I × I × I × (I ∪ V)), merge still union. ∎

Here the mismatch becomes a prediction. The 1999 core standardized triples. The deployed stack then grew exactly the fourth position: named graphs, RDF datasets, TriG, standardized in 2014. The graph name is a URI, so attribution itself dereferences. A derivation that merely matched the 1999 core could be coincidence. But the derivation’s one missing requirement generates the standard’s own later extension — so it is tracking the constraint, not fitting itself to the artifact. Honesty about the prediction’s scope: the position arrived, and the standard declined to fix what the graph name means; the semantics is argued about still. The prediction is structural, and claimed as nothing more. (Annotation syntaxes — RDF 1.2’s triple term — by contrast, only re-serialize what reification already expressed. A convenience, and honest as one; but syntax is not a property, and Part IV’s audit table scores properties.)

Mismatch three: the abandoned seam

Chapter 6’s crossing needs two pieces: a canonical serialization and a declarative tree-transformation language. The deployed stack had both, and the transformation language — XSLT — was standardized in 1999 and shipped in every browser. The platform then froze it at that 1999 revision for a quarter of a century and, as of this writing, is scheduled to remove it outright. So this mismatch is not a gap in the standards: the technology existed, and the platform stopped maintaining it. This is the evidence Chapter 6 promised — closing the seam requires no invention, only the upkeep of software that already existed. The platform declined the upkeep, and the industry built, many times over, the compensating machinery Part IV will measure.

Generalized, that is the book’s practical thesis: what separates the modern web from the derived one is abandoned technology — a maintenance failure, not a research problem. And the failure is the platform’s, not the language’s: XSLT 3.0 (2017) runs in every current browser through SaxonJS. Its IXSL extension binds browser events to template rules — Chapter 7’s mobility of evaluation, deployed, with interactivity still declarative. From userland, a vendor performs the maintenance the platform dropped.

Mismatch four: the write-side last mile

Forms, run backwards, want submissions that denote deltas (Prop. 7.2). The W3C Recommendation stack stops one step short: SPARQL Update carries the delta, but HTML forms speak application/x-www-form-urlencoded, and no recommendation bridges the two. The bridge exists as a community spec, RDF/POST. It flattens the triple positions into form keys (su, pu, ou, ol, …: subject, predicate, object, literal), so that a plain HTML form, with no script, submits a graph. It invents nothing: an encoding of the derived model into the form media type the web already ships. Its non-standardization is the write side’s most conspicuous open seam. (Disclosure: the spec is maintained by the author’s company, building on Sergei Egorov’s original draft. Chapter 18 shows it at work.)

The inventory

Four mismatches, then:

mismatch	seam	resolves as
the unnamed entities (Prop. 9.1)	model ↔︎ standard	a motivated extension, its cost computable — and billed to whoever chose anonymity
the fourth position (Prop. 9.2)	model ↔︎ standard	a prediction the standard later honored
the abandoned seam	standard ↔︎ platform	abandonment — maintenance, never research
the write-side last mile	standard ↔︎ platform	a bridge specified, never standardized

flowchart TB
    Model(["Model — what Part II forced"])
    Standard(["Standard — what Part III named"])
    Platform(["Platform — what ships (the browser)"])

    Model === Standard === Platform

    Model -. "model–standard seam" .-> m1["unnamed entities · Prop. 9.1<br/>a motivated extension"]
    Model -. "model–standard seam" .-> m2["fourth position · Prop. 9.2<br/>a prediction, later honored"]
    Platform -. "standard–platform seam" .-> m3["the abandoned seam<br/>maintenance, never research"]
    Platform -. "standard–platform seam" .-> m4["write-side last mile<br/>a bridge specified, never standardized"]

The four mismatches, placed. The derivation meets the world across two seams: the model (Part II) against the standard (Part III), and the standard against the platform that ships it. At the model–standard seam (Props. 9.1–9.2): a surplus the standard permits and the model never forced, and a requirement the model missed and the standard later honored. At the standard–platform seam: an abandonment and a bridge specified but never standardized — neither a research problem.

None touches the derivation: no proposition of Part II is weakened by anything in this inventory. A theory loses credibility where its mismatches are hidden and gains it where they are on the table. Ours are; now we audit everyone else’s.