Meaning Becomes the Source

The router of Chapter 5 has a memory problem. Consider what it did across a single week with the payments architecture document. On Monday it read the retry-policy passage, decided it was a process with topology, and generated a state diagram. On Wednesday it read the same passage for a different reader, decided it was a process with topology, and generated a timeline of the same retries. On Friday it rendered the passage as a table of backoff intervals. Three transformations, three fresh inferences of the same structure from the same prose — and nothing accumulated between them except the prose itself, which sat unchanged while the system re-discovered, each time, what it already knew.

Worse, the three views can disagree with each other. Monday’s diagram shows the partition exception redirecting to the dead-letter queue. Friday’s table omits the exception row for space. Wednesday’s timeline labels the third retry “final” without the partition qualifier. No single component is at fault: each generation was locally reasonable, each view is plausible on its own, and taken together they describe three slightly different systems. The reader who sees only one view inherits whichever distortions that rendering happened to introduce. The system has no stable object to check its views against — nothing between the source and the view except a fresh act of interpretation, performed anew each time, drifting each time.

This chapter earns the object that stops the drift. The claim is narrower than the chapter title sounds, so the qualification comes first and the title keeps its evocation on those terms:

If multiple representations are going to be generated from the same source, the system benefits from an explicit, source-linked intermediate representation of the communicative structure it intends to preserve.

“Meaning” here does not mean a complete machine-readable representation of human intent. It means an explicit derived representation of the source structure that the system is currently attempting to preserve and render — claims, relations, sequence, qualifiers, evidence links — no more. The record is an interpretation artifact. It is not the source, not the truth, and not the whole of what the source communicates. It is the thing views are checked against.

The hierarchy

Three levels, with the inequalities stated as architecture rather than slogan:

SOURCE
the original artifact, canonical, unchanged

  ↓ interpretation (fallible, logged, rebuildable)

SEMANTIC RECORD
a derived, inspectable model of
claims, relations, sequence,
qualifiers, evidence, uncertainty

  ↓ rendering policy (Chapters 4–5 machinery)

VIEW
prose / diagram / table / image /
timeline / interactive form

SOURCE ≠ SEMANTIC RECORD
SEMANTIC RECORD ≠ TRUTH
SEMANTIC RECORD ≠ COMPLETE MEANING

Each inequality carries engineering consequences. Source ≠ record means the record can be wrong about the source, so every entry carries source spans — character offsets, page anchors, timestamps — that let a checker walk from interpretation back to the words it came from. When the record says the retry policy has three exceptions and the source passage lists two, the spans expose the fabrication. Record ≠ truth means the record models what the source says, including the source’s own errors, disputes, and uncertainties: if the source claims a causal link the evidence does not support, the record stores the claim and the evidential status, not a corrected fact. Correcting sources is verification’s job (Chapter 7’s sidecar); the record’s job is faithful modelling of the sayable. Record ≠ complete meaning means tone, rhetoric, implication, and everything the schema cannot express remain in the source, retrievable through the escape hatch of Chapter 3 but not represented. The record is lossy by design, and its losses are declared rather than hidden.

This is also where the loose “meaning” of Chapters 1–3 gets redeemed operationally. The book no longer asks whether the machine captured meaning in some philosophical sense. It asks, per record entry: is this claim present in the source at these spans? Is this relation’s direction as stated? Is this qualifier attached? Those are checkable questions, and Chapter 9 will build the full instrument that checks them. This chapter builds the object worth checking.

A minimal schema, earned by failures

The record starts small. Not an ontology of everything, but the smallest structure whose absence has already caused visible failures in Chapters 4 and 5:

concepts        the entities a passage is about
claims          atomic statements the source makes
relations       directed connections between claims/concepts
qualifiers      scope, condition, exception, uncertainty on each claim
sequence        ordering where order carries content
evidence links  pointers to the material backing each claim
source spans    where in the source each entry came from

Each field is justified by a failure the book has already met. Claims exist because Monday’s diagram and Friday’s table disagreed about how many exceptions the policy has — atomic, countable statements make disagreement detectable. Relations with direction exist because DiagramEval showed generators corrupt arrows while preserving boxes: direction must be stored explicitly or rendering will invent it. Qualifiers exist because Chapter 4’s spin evidence showed compression concentrating distortion exactly on scope conditions and non-significance statements — the field most likely to be dropped is the field that must be structurally attached. Sequence exists because timelines and processes carry order as content. Evidence links and source spans exist because nothing in this architecture is trustworthy without a walk back to the source; they are the mechanism of the Chapter 3 escape hatch at the granularity of individual claims rather than whole documents.

Richer fields — argument structure, rhetorical role, confidence calibration, cross-document identity — are refused for now. Each may earn its place later, when a chapter demonstrates a failure the minimal schema cannot express. The schema grows by necessity, not ambition. That is the first-principles style applied to data modelling: every field must be traceable to a breakage. And the systems sentence that protects every later reference: a semantic record is useful because it makes selected relationships explicit and inspectable, not because it captures the source’s complete meaning. Chapters 7–10, 36, and every experiment that grounds on the record inherit that boundary with the object.

Two deliberate non-features deserve emphasis. First, the record stores no rendering decisions: it does not know whether claim 7 belongs in a diagram or a table. Representation policy (Chapters 4–5) reads the record; the record does not anticipate the policy. This separation is what lets one record feed many views without being rewritten per view. Second, the record stores no reader state: it does not know who finds what novel or relevant. Task conditioning (Chapter 14) and novelty (Chapter 15) arrive downstream as queries against the record, not as fields within it. The record models the source; everything personal is a lens applied later. That layering is what keeps one stable object serving many readers.

The key comparison: direct versus mediated generation

The chapter’s proposition is not “an LLM can extract claims” — extraction accuracy alone would prove little, since a system that extracts beautifully and then ignores its own ledger when rendering has gained nothing. The proposition is architectural:

Does an explicit intermediate representation improve a system that must repeatedly transform the same information?

EXP-06 below tests exactly this, comparing two pipelines on the same sources and the same set of required views:

A. direct generation (each view from source, fresh)

source → table
source → diagram
source → summary

B. mediated generation (record once, render repeatedly)

source → semantic record → table
                         → diagram
                         → summary

The measures target the drift this chapter opened with: consistency across views (do the table, diagram, and summary agree on the same claims?), claim and relation preservation against a human-adjudicated ledger, qualifier preservation specifically, unsupported additions per view, cross-view contradictions (the Monday/Wednesday/Friday disease, counted directly), and traceability (what fraction of rendered statements resolve to record entries with source spans?). Pipeline B wins only if the record constrains generation — if the views agree more, contradict less, and trace further. If pipeline B merely adds latency while the same distortions recur, the record is ornamental and the chapter’s claim fails. That negative result is kept either way: it would show the bottleneck is generation fidelity rather than architectural memory, redirecting effort to instance quality (Chapter 5’s other half) rather than intermediate objects.

The adversarial condition

Both pipelines face source material designed to break the careless — three constructions, each easy to state and easy to destroy:

A causes B only under condition C.

D is associated with E,
but the source explicitly rejects causation.

Method X outperformed Y
except in subgroup Z.

These demand, respectively: relation with attached condition (drop C and the claim becomes false); association distinguished from causation with the rejection preserved (upgrade to causation and the system has asserted what the source denied); comparative claim with scoped exception (drop Z and the table recommends X where the source warns against it). The record must hold relation, direction, qualification, exception, and uncertainty as separate, attached structure — not as prose annotations a renderer may skim past. The generated views then reveal whether the record actually constrained them: a diagram that draws the A→B arrow without the C gate, or a table that ranks X above Y with no Z footnote, convicts the pipeline regardless of how polished it looks. This adversarial set is small on purpose. It tests the joints where real documents break, and it previews the preservation methodology Chapter 9 generalises: every transformation is scored on what it did to exactly these load-bearing joints.

Protecting Chapter 9

This chapter measures enough fidelity to justify the intermediate object — claim/relation/qualifier capture, unsupported additions, cross-view contradiction counts — and stops there. It does not build the complete preservation profile: no emphasis-shift metrics, no numeric-fidelity stress tests, no provenance-recovery scoring, no summary-level factuality benchmarks. The ownership is:

CH 06
We need an explicit intermediate representation,
and here is the evidence that it constrains generation.

CH 09
Now we need a rigorous way to measure
whether transformations through that representation
actually preserved what mattered — across every
transformation type in the book.

Chapter 6 motivates the instrument; Chapter 9 builds it. If this chapter sprawled into full measurement, Chapter 9 would have nothing to earn and the Part’s climax would deflate. Restraint here is structural, not modest.

What this chapter earned

A derived, inspectable, source-linked record — minimal, failure-justified, rendering-agnostic, reader-agnostic — that sits between source and views and constrains repeated generation. Not meaning itself; the structure the system currently attempts to preserve, with inequalities that keep it honest and spans that keep it checkable. The router of Chapter 5 no longer re-infers structure from scratch; it reads the record. And once the system holds a structured model of what the current page says — its claims, concepts, relations, evidence — a new possibility opens that needs no further machinery to state: that structure can become queries into the surrounding information world. The page knows what it is about. What else should enter the interaction?

Once the medium understands structure, it can bring the surrounding information world into the interaction.

References

• Cao, Jiang & Xia (CHI 2025). Reused: the task-driven data model as precedent for model-mediated UI generation; the semantic record generalises Jelly’s task model from interaction tasks to communicative structure. No new claims taken.
• DiagramEval (EMNLP 2025). Reused: node/path alignment as the instance-level check inside EXP-06’s mediated pipeline; relation-direction storage motivated by path-alignment failures.
• The author’s Context From First Principles (representation as a separate context decision) and Embeddings From First Principles (preservation-profile principle): cited as conceptual inheritance only — sibling repositories not yet inspected at drafting time; specific mechanisms to be verified against those sources at the Part I coherence pass before they carry argumentative weight.
• RELATE / relation-projection material: deliberately not used here; relation typing across documents belongs to Chapter 8.

Proposed experiment EXP-06: direct versus mediated multi-view generation

Status: PROPOSED. Corpus: a small set of dense technical passages including the three adversarial constructions (conditioned causation; association-with-rejected-causation; scoped comparison exception), with a human-adjudicated ledger of atomic claims, relation directions, qualifiers, and source spans. Pipeline A (direct): each required view (table, diagram, summary) generated fresh from source. Pipeline B (mediated): one semantic record extracted first (logged, span-anchored), then all views generated with the record as grounding context and every rendered statement required to cite record entries. Human judges blind to pipeline score: per-view claim/relation/qualifier capture and unsupported additions; cross-view contradiction counts on shared claims; traceability fraction (rendered statements resolving to spans). Also scored: record quality itself (extraction precision/recall vs ledger) reported separately so extraction error and constraint failure do not confound. Failure criteria: B ≈ A on contradictions and qualifier capture (record ornamental); B wins consistency but loses on unsupported additions (record stabilises structure while generation still fabricates — redirects to instance fidelity); record extraction itself below usable quality (architectural question moot until extraction improves). Artifacts expected: source pack, human ledger, record dumps with spans, view sets per pipeline, contradiction matrix. What a positive result would not justify: that the record captures “meaning” completely, or that any full preservation metric exists yet — measurement completeness belongs to EXP-09.