Cyphia Solutions LLC
Draft v2 · August 2026
Retrieval-augmented generation still treats most documents as flat text. The dominant pipeline splits a document into fixed-size chunks, embeds each chunk into a single vector, and retrieves the top-k most similar chunks as “context.” This design discards, at ingestion time, nearly everything the document's author declared about its own organization: that this line is a heading and that one a footnote; that this number is qualified by a row header two cells to its left and a column header one row above; that this paragraph belongs to the section “Exclusions” and not to “Coverage”; that this figure has an authored textual description. What the retriever later struggles to recover — often with a layout model or an LLM — is frequently information the source file contained all along.
A rapidly growing body of work adds structure back. We read this literature as three generations, distinguished by the question each answers. The first generation retrieves better passages — lexical ranking, dense embeddings, and multi-vector late interaction [10] ask which pieces of text resemble this query? The second generation organizes information before retrieval: recursive summary trees [7], LLM-extracted entity graphs with community structure [8], associative memories over open knowledge graphs [9], and, most recently, navigable document hierarchies with stateful evidence accumulation [3] ask which structure helps us navigate the corpus? The third and newest generation constructs what the answer requires: query-specific evidence graphs built on the fly [4], question-conditioned relational schemas induced over document collections [6], and adaptive graph retrieval that treats the derived graph as a semantic skeleton grounded in the original document [5] ask what evidence structure does this query need?
Across all three generations, one assumption survives almost untouched: structure is something a system must recover. Hierarchies are reconstructed from layout analysis and reading-order heuristics [3, 12]; relations are extracted by LLMs and repaired at query time [4, 8]; schemas are induced per question [6]. Even the most document-native of these systems re-derives its hierarchy from parsed layout and keeps the normalized paragraph — 200 to 400 tokens, merged and split to fit — as its atomic evidence unit. Yet a substantial and growing class of documents already carries an authoritative, machine-readable account of its own structure. Tagged PDF [13] — mandated by accessibility law in much of the world and produced at scale by authoring and remediation pipelines — embeds a logical structure tree: element roles, ordered hierarchy, reading order independent of layout, table header scopes and spans, figure alternative text, footnote and link targets, and an anchor from every logical element to the exact content it realizes on the page. This structure is not a model's guess about the document. It is part of the document.
This paper asks the question that assumption obscures: when a trusted structural representation already exists, how much do we lose by discarding it and asking AI to rediscover it? And its converse, which turns out to be equally informative: when the declared structure is poor, does it still help?
We present Evidence Graph Retrieval (EGR), built on a simple inversion: don't chunk a structured document — compile it; don't retrieve passages — construct evidence.1 An EGR compiler transforms a tagged PDF's structure tree, content anchors, attributes, and reference objects into a persistent source graph whose nodes are the document's own logical elements and whose fragments retain exact source anchors (page, content stream, marked-content ID) and geometry. Deterministic relations are derived from source facts: reading order, level-aware heading scope, and table header applicability computed from declared scope and span attributes. Semantic assertions may be layered on top. Crucially, every edge carries an epistemic origin: the graph is internally stratified into what the source declared (Gsource), what is deterministically derivable from it (Gderived), and what a model inferred (Ginferred). An extraction hallucination can corrupt only the layer marked as fallible; the authoritative substrate is immutable by construction. At query time, EGR compiles a question into explicit requirements and constructs a compact, provenance-preserving evidence set that satisfies them — not “navigate until the model says enough,” but a coverage-constrained selection over typed evidence.
We are explicit about what we do not claim. Navigating document graphs vertically and laterally while accumulating evidence state is established [3]; constructing query-specific evidence graphs dynamically is established [4]; grounding a derived graph back to its source document is established [5]. Our contributions are orthogonal to all three:
Our evaluation makes the value of declared structure measurable: tagged PDF supplies a ground-truth structural graph authored with the document, so gold evidence is annotated at the structure-node level, questions are stratified by the topology of their required evidence, and identical retrieval machinery runs over declared versus reconstructed substrates. The headline findings are summarized in the abstract; the through-line is stated plainly: only well-tagged — perfect or near-perfect — structure is meaningful for retrieval. Below a quality threshold, declared structure misleads; in the compliance band it merely matches chunking; professionally remediated structure dominates chunking on both recall and context cost simultaneously.
1 The architectural thesis — that tag-level retrieval with precise source references should replace flattening semantic PDF structure into equal-role chunks — was first articulated by the author in a 2023 white paper [1], more than two years before the present work. The system and experiments reported here were designed and developed independently; the concurrent third-generation systems discussed in §2 were identified in a subsequent literature review conducted for positioning, and none influenced the design.
Passage retrieval. BM25, dense bi-encoders, and late-interaction models [10] rank text spans by query similarity. They are components inside EGR — seed generation uses lexical and dense channels with reciprocal-rank fusion — but do not address evidence composition: no similarity function knows that a cell is qualified by a header or a claim by a footnote. The representational ceiling of single-vector retrieval [2] further motivates architectures whose expressiveness lives outside the embedding.
Organized retrieval. RAPTOR [7] builds a hierarchy by recursive clustering and summarization — a similarity hierarchy answering “which pieces talk about similar things,” where ours is an authorial hierarchy answering “how did the author organize these pieces”; the two are complementary, not interchangeable. GraphRAG [8] extracts an entity/relation graph with LLMs and retrieves via community structure; an extraction error there alters the structural representation itself, whereas in EGR it can only touch the layer marked Ginferred. HippoRAG's Personalized-PageRank propagation [9] is a candidate mechanism inside EGR's graph search rather than an alternative architecture.
Constructed evidence. Relink [4] rejects build-then-reason GraphRAG for reason-and-construct: assembling a compact query-specific evidence graph, instantiating missing relations on demand. We share the endpoint but not the ontology: Relink's graph is factual triples with sentence-level provenance; ours is document topology whose provenance chains reach claim → cell → row/column headers → caption → section → page/MCID. Relink constructs missing semantic relations; EGR composes existing structural evidence. DocSage [6] induces a query-specific relational schema over unstructured corpora — the mirror image of our approach (“infer the structure this question needs” versus “preserve the structure the document has; infer only what is missing”); the combination is promising future work. PAGE-RAG [5] is philosophically closest: the derived graph is an incomplete projection and the source remains truth. We push further: in tagged documents part of the graph is source truth, so the graph is internally stratified rather than wholesale derived. GRATR [11] applies evidence-graph vocabulary to trust reasoning in games; the connection is limited to the general insight that relations among observations affect how they support a conclusion.
Document-structured RAG. DocNavRAG [3] is the nearest neighbor: it exposes a document-native hierarchy as a navigable search space with stateful evidence accumulation. Its hierarchy, however, is reconstructed — MinerU layout parsing [12] yields regions, title attributes, and reading order — and its evidence units remain normalized 200–400-token paragraphs. DocNavRAG's graph tells an agent where to look; a compiled tagged table tells ours what a value means. Our reconstruction ablation (§6.4) quantifies exactly this difference with the retrieval machinery held constant.
Tagged PDF and accessibility. The 2023 proposal [1] argued that fixed-size chunking loses document semantics, that tagged PDFs expose logical hierarchy usable for retrieval, and that tables and figures should retain structural representations with precise tag-level source references. This paper adds what was missing then: formal graph semantics, epistemic provenance, query-conditioned evidence construction, and controlled experimental validation. The accessibility ecosystem plays a second role in our design: validator scores [13] become per-document quality covariates for the tag-quality study (§7.3).
An EGR corpus is a typed graph over four object families.
Structure nodes mirror the document's logical elements. Each node records its role twice — the raw role as authored (e.g., a custom Heading 1) and the effective role after role-map normalization (HEADING) — plus ordered children, resolved attributes (the raw owner dictionaries and the merged view), accessible text variants (ActualText, Alt, expansion, language), and source identity (PDF object reference, optional structure ID).
Source fragments anchor nodes to realized content: page index, marked-content ID, containing content stream or Form XObject (an MCID alone is not a global key), extracted text, and per-line bounding geometry. Artifact and untagged content are represented with an explicit status rather than silently discarded.
Edges are typed twice: by relation (CONTAINS, PRECEDES, REALIZED_BY, HEADING_FOR, ROW_HEADER_FOR, COLUMN_HEADER_FOR, LINKS_TO, and semantic types such as SUPPORTS/CONTRADICTS in a later phase) and by epistemic origin: SOURCE_* origins mark facts the file declares (the tag tree, marked content, a table header's /Scope, a link annotation); DETERMINISTIC_DERIVATION marks relations computed from source facts by fixed rules (level-aware heading scope; positional table-header fallback); MODEL_INFERENCE and HUMAN are the only strata where fallible judgment enters. Formally, the corpus graph is the disjoint union of three strata with a fixed trust ordering:
where enrichment may only add to Ginferred (or, by fixed rules, to Gderived) and may never rewrite a higher stratum; disagreement between strata is surfaced as a diagnostic, never resolved by overwriting.
Diagnostics record what the source got wrong — empty elements, irregular tables, unresolved references — plus ingested accessibility-checker findings and the document's validation score. A tagged PDF is not necessarily a correctly tagged PDF; diagnostics let experiments separate retrieval failures from source-quality failures, and they operationalize the quality-gradient study.
flowchart TB A["Tagged PDF\n(structure tree, MCIDs,\nattributes, annotations)"] --> B["EGR compiler\nroles · anchors · geometry\ntable semantics · heading scope"] B --> C["Source graph\nG_source ∪ G_derived\n(+ diagnostics, validation score)"] C --> D["Indexes\nBM25 · dense · heading paths"] Q["Question"] --> E D --> E["Seed channels\n(rank fusion)"] E --> F["Deterministic structure\nexpansion (EGR-S)"] C --> F F --> G["Evidence-set optimization\n(EGR-Full)"] G --> H["Evidence + provenance\n(node IDs → page/MCID)"]
The compiler traverses the structure tree in authoritative /K order, preserving raw and mapped roles; creates fragments for every content reference with (page, stream, MCID) anchors, text, and geometry; resolves attributes; derives deterministic edges; runs diagnostics; and emits canonical, diffable JSON (recompiling a document yields byte-identical output). Three derivations matter most for retrieval:
Table semantics — declared before inferred. For every table, cells are placed on a grid honoring RowSpan/ColSpan; headers attach to cells by fixed priority: explicit /Headers ID references; declared /Scope semantics (a Scope=Row header emits ROW_HEADER_FOR to the cells right of it across its span; Scope=Column downward; Both does both) — all with origin SOURCE_ATTRIBUTE; and only for cells still uncovered on an axis, positional inference with origin DETERMINISTIC_DERIVATION. Cells routinely acquire both a row and a column header. Irregular tables are diagnosed, not repaired.
Heading scope in flat sequences. Headings function as section boundaries even when the tag tree is flat. A heading receives HEADING_FOR edges to its following siblings until the next heading of equal or higher level, so an H2's scope flows across intervening H3/H4 subsections. Retrieval expansion and index-time contextual projections both consume these edges.
Container transparency. Grouping containers with no semantics of their own (NonStruct) remain in the graph as source truth but are transparent to every derived relation: adjacency, heading scope, and traversal splice through them. Similarly, corpora that tag cell text in nested children (TD > P > text) are handled by letting content seeds adopt their enclosing cell.
Extraction validation. The reference implementation consumes a verbose structure dump emitted by an accessibility-industry extraction tool (to an interface we specified), cross-validated against an independent Python extraction stack — element counts, roles, text, and geometry agree on all pilot documents, and the dual pipeline caught real extractor defects (text duplication; silently skipped encrypted files; malformed span values in the wild, e.g. ColSpan="#274").
Seed generation. Independent channels retrieve candidate nodes: BM25 over node text (with CJK unigram tokenization); dense retrieval over node text; and a structural channel — BM25 over governing-heading chains (“Getting Legal Help › 2.1 What Kind of Legal Help do I Need?”) that surfaces a section even when its body shares no vocabulary with the query. Channels fuse by reciprocal rank. Two negative results shaped the design: fused head-to-head, the structural channel floods the top-k for any query naming the document (heading paths share the document-title prefix), so it contributes a bounded number of seeds; and dense scoring over short heading strings is noise, so the channel is lexical-only.
Deterministic structure expansion (EGR-S). Each seed expands along compiled edges: reading-order neighbors; governing headings; for heading seeds, the section's content with candidates selected by query-token overlap rather than blind reading order; for table cells, their compiled row/column headers, the full row (whole table when small), and the column headers of row-mates (matrix tables answer “which column is marked” through that 2-hop). For large tables, expansion is query-conditioned: header cells whose tokens all appear in the query select their axes, and the intersection of their edge targets pinpoints value cells — “net YTD return” resolves as targets(ROW_HEADER_FOR NET) ∩ targets(COLUMN_HEADER_FOR YTD). No model is consulted anywhere in this layer.
Evidence-set optimization (EGR-Full, v0.1). The target object is a compact evidence set satisfying explicit requirements, not a ranked list. Let a compiled query Q = {r1, …, rm} be a set of requirements, of which Qhard ⊆ Q must be satisfied. EGR selects
where Cost is retrieved context (words) and Redundancy penalizes items adding no marginal coverage. The exact optimum is not required: v0.1 solves (2) greedily — requirements are proxied by the query's content terms; selection maximizes marginal coverage per unit cost; a structural closure keeps evidence bundles intact (a selected value cell brings its headers along *_HEADER_FOR edges); a support floor guards degenerate selections. This implements “construct a minimum-cost subgraph satisfying an evidence specification” in its simplest falsifiable form; typed requirements with a verification loop are future work.
| Corpus | Docs | Validation scores | Indexed nodes | Chunks | Gold questions | Languages |
|---|---|---|---|---|---|---|
| Pilot | 12 | 84.5–100 | 18,762 | 196 | 40 dev + 25 held-out | EN, FR, DE |
| Perfect | 87 | 98.1–100 | 84,014 | 2,206 | 29 | EN, FR |
| Gradient | 62 | 55.2–97.2 | 24,942 | 1,714 | 30 | EN, ZH |
Gold evidence. 124 questions are annotated at structure-node granularity: each question lists required-evidence slots, each slot satisfiable by any of its listed nodes, each node pinned with a verbatim evidence substring and machine-validated against the compiled corpus. Questions are stratified by required-evidence topology: L0 single node; L1 adjacent nodes (label/value pairs); L2 heading-scoped sets (list items meaningless without their heading); L3 distant nodes in one document; L4 table/figure composition (cell + row header + column header; alt-text-only evidence). The pilot development set was used during system development; the 25-question held-out set was authored after all parameters were frozen; the perfect- and gradient-corpus sets were authored before any system ran on those corpora. The perfect corpus contains ≈30 near-duplicate fund fact sheets as deliberate cross-document distractors.
Metrics. A question q specifies slots Sq, each slot satisfiable by any of a listed set of gold nodes with pinned evidence strings. For a retrieved set R:
with covered(s, R) true iff some item in R is one of the slot's gold nodes, or comes from the same document and textually contains the slot's evidence string. The rule is deliberately chunk-favorable — a chunk is credited whenever the needed evidence appears anywhere inside it. We also report the full-answer rate (all slots of a question covered) and retrieved words (context cost).
Systems. Chunk baselines (fixed ≈800-token windows over flat extracted text; dense, and BM25+dense hybrid); tag-aligned node baselines (dense; hybrid; heading-contextualized); EGR-S; EGR-Full; and the reconstruction ablation. Embedders: a static multilingual model (model2vec potion-128M) and a transformer (paraphrase-multilingual-MiniLM-L12-v2); findings replicate across both.
Reconstruction ablation. The pivotal comparison rebuilds every document without reading the tag tree: a widely deployed layout-recovery pipeline (pymupdf4llm: font-size heading inference, visual reading order, list and table detection) parsed into the same graph schema, with the same heading-scope and adjacency derivations, indexed and retrieved by the same code path. The only experimental variable is where structure came from.
| System | Recall | Full | Words | L0 | L1 | L2 | L3 | L4 |
|---|---|---|---|---|---|---|---|---|
| chunk-dense | 0.875 | 0.88 | 5,705 | 0.75 | 1.00 | 1.00 | 0.67 | 0.92 |
| chunk-hybrid | 0.975 | 0.97 | 5,762 | 0.92 | 1.00 | 1.00 | 1.00 | 1.00 |
| node-hybrid | 0.640 | 0.47 | 201 | 1.00 | 0.50 | 0.36 | 0.83 | 0.49 |
| EGR-S | 0.977 | 0.95 | 1,476 | 1.00 | 1.00 | 0.90 | 1.00 | 1.00 |
| EGR-Full | 0.793 | 0.70 | 242 | 0.92 | 1.00 | 0.44 | 0.83 | 0.85 |
| recon-hybrid | 0.528 | 0.45 | 320 | 0.83 | 0.12 | 0.35 | 1.00 | 0.38 |
| recon-EGR | 0.611 | 0.55 | 1,134 | 0.83 | 0.38 | 0.46 | 1.00 | 0.49 |
Bare tag-aligned nodes (node-hybrid) are perfect on single-node questions and collapse exactly where evidence is distributed — the German hotline number node “116 111” is unfindable by itself (L1 0.50); list items under “Not accepted in recycling” are innocuous nouns without their heading (L2 0.36); a table cell without its headers is a bare number (L4 0.49). This failure pattern tracks topology class, not question difficulty: composition, not granularity, is what chunking's context buys and what the graph supplies cheaply.
| System | Transformer embedder | Static embedder | ||||
|---|---|---|---|---|---|---|
| Recall | Full | Words | Recall | Full | Words | |
| chunk-hybrid | 0.900 | 0.84 | 5,672 | 0.860 | 0.80 | 5,752 |
| node-hybrid | 0.730 | 0.56 | 174 | 0.643 | 0.40 | 174 |
| EGR-S | 1.000 | 1.00 | 1,373 | 0.960 | 0.96 | 1,208 |
| EGR-Full | 0.773 | 0.68 | 171 | 0.780 | 0.72 | 184 |
| recon-EGR | 0.750 | 0.64 | 1,005 | 0.740 | 0.64 | 998 |
On held-out questions EGR-S achieves perfect evidence recall — 1.00 in every topology class — at 4.1× less retrieved context than the chunk hybrid (0.90). There is no tuning collapse across sets (0.977 development → 1.000/0.960 held-out), and chunking's held-out drop (it misses buried single facts: L0 = 0.67–0.78 across embedders) previews the scale effect of §7.2. EGR-Full compresses to ≈170 words per question — 33× less than chunks — at 0.77 recall; its documented weakness is enumeration questions under token-proxy requirements (L2 ≈ 0.5).
Declared versus rediscovered structure. Running identical machinery over the reconstructed substrate loses 25–37 recall points (Tables 2–3), with a gradient that is itself the thesis: no gap on plain-paragraph questions (L3), catastrophic gaps where structure is load-bearing. The reconstruction failures are ordinary, not adversarial: one poster reconstructs to zero content (the layout pipeline classifies all 1,051 characters of text away); two-column fact-sheet tables are not detected as tables; bold captions are over-detected as headings (215 of 323 blocks in one document); a designed grants table loses its pairings. Expansion still helps the reconstructed substrate (+8–10 points over its own hybrid baseline) — the machinery is substrate-agnostic — but cannot recover what the parser never captured.
| System | Best recall (k ≤ 30) | Words at best | Words to reach 0.90 | Recall @ k=10 | Words @ k=10 |
|---|---|---|---|---|---|
| chunk-dense | 0.38 | 17,394 | — | 0.29 | 5,743 |
| chunk-hybrid | 0.83 | 11,628 | never | 0.70 | 5,748 |
| node-hybrid | 0.62 | 526 | — | 0.56 | 271 |
| EGR-S | 0.925 | 2,203 | 1,207 | 0.925 | 2,203 |
| EGR-Full | 0.76 | 287 | — | 0.71 | 259 |
| recon-EGR | 0.68 | 6,843 | — | 0.63 | 2,577 |
At 87-document scale the pilot's apparent chunking parity evaporates. On the 12-document pilot, chunk-hybrid scored 0.98–1.00 because five 600-word chunks could swallow whole documents; at 87 documents — including ≈30 near-duplicate fund fact sheets — its recall falls to 0.70 while EGR's context cost stays flat, exactly as pre-registered. Single-vector chunk retrieval collapses hardest (0.29): it cannot discriminate near-identical documents. Chunking cannot reach 90% evidence recall at any context size tested — it plateaus at 0.83 while consuming 11,600 words per question; EGR-S crosses 0.90 with 1,207 words and reaches 0.925 (0.90 full-answer) at 2,203. The claim is no longer “same recall, fewer words”; it is recall that chunking cannot buy at any tested price, at 5–10× less context. Remaining EGR misses are seed-side: one question whose evidence (“NOT FDIC INSURED…”) shares no vocabulary with any natural question (every system scores 0 on it), and two partials where seeds land in the wrong fund's identical-looking table row — motivating a document-scoping seed channel as future work.
| Score band | n (questions) | EGR-S | chunk-hybrid | recon-EGR | Δ |
|---|---|---|---|---|---|
| < 70 | 5 | 0.60 | 1.00 | 0.80 | −0.40 |
| 70–85 | 13 | 0.92 | 0.85 | 0.92 | +0.08 |
| 85–97 | 12 | 0.88 | 0.96 | 0.88 | −0.08 |
| ≥ 98 (professional) | 29 | 0.93 | 0.70 | 0.63 | +0.23 |
The threshold is real. Below a validation score of ≈70, EGR-S loses to chunking decisively (Δ = −0.40). The observed low-band failure modes are structural, not incidental: a score-55 document whose tag tree runs pages in the order 11, 12, 3, 20; a flat 674-paragraph bibliography whose answer context is split across nodes that chunking happily aggregates. On this band, reconstruction is competitive with tags — indeed, across the gradient corpus the layout parser recovers more text than the tag trees carry (37,550 vs. 24,942 nodes), the inverse of the perfect corpus — the core thesis run in reverse: when nothing meaningful is declared, rediscovery is as good or better.
| Score | Document | Headings | TH | TD | Header edges | Scope edges | EGR-S |
|---|---|---|---|---|---|---|---|
| 55.2 | correspondence-course monograph | 0 | 0 | 0 | 0 | 0 | 0.50 |
| 65.5 | edited-volume bibliography | 0 | 0 | 0 | 0 | 0 | 0.00 |
| 80.6 | accessible-PDF example file | 26 | 28 | 26 | 47 | 98 | 1.00 |
| 89.4 | convention program book | 0 | 0 | 0 | 0 | 0 | 1.00 |
| 91.2 | class schedule | 0 | 14 | 30 | 39 | 0 | 0.25 |
| 95.6 | privacy policy | 18 | 3 | 21 | 21 | 101 | 1.00 |
| 97.2 | journal article | 15 | 0 | 0 | 0 | 362 | 1.00 |
The checker score is a weak proxy for structural fitness. The raw correlation between validation score and EGR recall is small (Spearman ρ = +0.21; ρ = +0.11 against the EGR−chunk delta), and Table 6 shows why: a document can score 89–91 while carrying zero headings, tables, or lists — a compliant flat run of paragraphs — while a document scoring 80.6 is structurally rich (and EGR aces it). Accessibility checkers measure compliance — alt text present, language set, no parse errors, content tagged or artifacted — not semantic richness. The better predictor of retrieval value is the compiler's own structural statistics (header-edge and heading-scope counts, role diversity), available for free at compile time. The professionally remediated ≥98 corpus differs from the 85–97 band not mainly in score but in declared semantics: real heading hierarchies, real TH cells with scope, real list structure.
Read together, the three studies support a single conclusion: only well-tagged — perfect or near-perfect — structure is meaningful for retrieval. Declared structure below the quality threshold misleads (−0.40); compliance-grade structure merely matches chunking (±0.08); professionally remediated structure dominates chunking on recall and context cost simultaneously (+0.23 at 5–10× less context, with table questions at 1.00), and dominates its own reconstruction by 25–30 points. The gate is not the checker score per se but the semantic structure that professional remediation produces and the checker only partially measures.
For retrieval systems. The economics favor compilation wherever trustworthy tags exist. All EGR layers evaluated here are deterministic — the only model in the loop is a seed-stage embedding; retrieval latency is dominated by brute-force cosine over ≤84k vectors (milliseconds), and the 4–33× context reduction compounds into every downstream token cost. Where tags are absent or poor, reconstruction remains the only option — our claim concerns what to do when declared structure exists, and how to decide (measurably, at compile time) whether it is trustworthy.
For the accessibility industry. The gradient study sharpens the business case for remediation beyond compliance. Passing a checker at 90 does not, by itself, buy retrieval value: the 70–97 band achieves parity with chunking. What converts a document into retrieval infrastructure is semantic remediation — real heading hierarchies, table headers with declared scope, list structure — precisely the practices that professional remediation applies and that compliance-only workflows may skip. Accessibility and machine-readability are the same investment; this work quantifies the second dividend.
For evaluation methodology. Node-level gold evidence with topology stratification localizes failures in a way aggregate QA scores cannot: it distinguishes “the fact was not retrieved” from “the fact was retrieved without the header that gives it meaning.” The reconstruction ablation — same machinery, different substrate — isolates the variable every second-generation system leaves confounded.
Gold sets were drafted by a single annotator (machine-validated against the corpora; a second-annotator pass is planned), and band sizes in the gradient study are small (5–13 questions). Question-class mix is constrained by what each document's structure can host — structurally hollow documents cannot carry table-composition questions — so band aggregates partially reflect question mix; per-document tables control for this better. The reconstruction ablation uses pymupdf4llm; a MinerU [12] replication is pending (the reconstructor is a drop-in module). The coverage rule's text containment favors chunk and reconstruction systems, which cannot match gold node identities. EGR-Full's requirement model is a token proxy; typed requirements with a verification loop, and the semantic stratum (claims, SUPPORTS/CONTRADICTS), are future phases and were not needed for any result reported here. Evidence metrics measure retrieval, not generation; an answer-generation study (does perfect evidence at 4× less context yield better, cheaper, more attributable answers?) is natural follow-on work. Finally, all experiments share one implementation of the compiler and one extraction toolchain; independent replications are welcome — the corpus manifests, gold sets, and evaluation code are designed to be released.
The retrieval literature has spent three generations teaching systems to rediscover document structure. For a large and growing class of documents, that structure is already present — authoritative, machine-readable, anchored to the exact bytes that realize it — and ignoring it is a measurable loss: on held-out questions, perfect evidence recall at four times less context than chunking; at realistic corpus scale, recall levels chunking cannot reach at any tested budget; and a 25–30-point penalty for rediscovering what was already declared. The advantage is gated by quality: only well-tagged, near-perfect structure delivers it, which makes semantic remediation not a compliance cost but a retrieval investment. Compiling declared structure into an epistemically stratified evidence graph turns retrieval from similarity search over fragments into construction of auditable evidence. The document already told us how it is organized. Retrieval should start by believing it.