Retrieving Unwritten Facts by Climbing the Type Hierarchy

When a retrieval-augmented language model answers an expert question, it searches a document collection for passages that mention the entities in the question. This fails in a predictable way. Authors write down what is surprising about a specific drug, disease, or device. They leave out what follows from the kind of thing it is. A pharmacology text may never say that a particular beta-blocker is dangerous in asthma, because it said so once for the whole drug class. The missing fact is written, but at a coarser level of description than the question uses. We propose to test this directly and to build a retriever around it. When evidence about an entity is missing, the retriever moves up a curated type hierarchy to the most specific category at which the needed fact is actually written. It retrieves that category-level passage, and the generator then applies the fact back to the original entity through an explicit chain: "X is a T, T has property P, so X has P."

The idea joins two literatures that have not been connected. Work on reporting bias shows that text systematically omits mundane, self-evident facts, and that language models inherit and even amplify this omission. Work on fine-grained entity typing shows that fine type labels give strong constraints for disambiguation and downstream reasoning. Our claim is that reporting bias depends on granularity: facts omitted at the instance level are often stated at the type level. If that holds, a large share of the knowledge that expert RAG systems currently cannot find becomes findable, and no new text needs to be generated to recover it.

Core Claim and Motivation

Three findings motivate the proposal. Towards Medical Machine Reading Comprehension with Structural Knowledge and Plain Text (KMQA) combines textbook retrieval with a medical knowledge graph on the Chinese pharmacist exam. Its error analysis attributes 44% of failures to information absent from both the text and the graph. Can large language models reason about medical questions? audits chain-of-thought reasoning on medical exams. It finds the logic sound in most cases, but 58% of errors come from missing or wrong factual knowledge, and Wikipedia retrieval gave only marginal gains. Do Neural Language Models Overcome Reporting Bias? shows that models trained on text overweight sensational events and underweight mundane ones. That paper's proposed fix is multimodal grounding, which does not apply in abstract professional domains.

We hypothesize that "absent" in the KMQA sense often means "absent at the granularity the retriever queried." The core empirical claim is falsifiable. It states that, for a meaningful fraction of premises that fail at the instance level in expert medical questions, there is a type ancestor in an ontology such as UMLS whose passages state the premise. The method claim is narrower. It states that retrieving at the most specific supporting ancestor, and then explicitly instantiating the fact, beats retrieval on surface strings, retrieval over graphs, and model-generated abstraction, with the largest gains on rare entities.

How This Differs from Existing Work

Three RAG systems address a "granularity gap," but none addresses this one. Cross-Granularity Hypergraph Retrieval-Augmented Generation for Multi-hop Question Answering (HGRAG) links entity nodes to the passages that contain them and spreads relevance across that structure. Its entities are surface strings with no type hierarchy, so a fact stated only about a class never connects to an instance. Retrieval-Augmented Generation with Hierarchical Knowledge (HiRAG) builds abstraction layers by clustering extracted entities and having an LLM write summaries. Its hierarchy is therefore derived from the corpus and generated by a model, not taken from a curated ontology. Its summaries also abstract only what the base graph already extracted. Typed-RAG types the question's form (comparison, reason, and so on), not the entities it mentions.

TAdaRAG builds task-specific knowledge graphs on the fly for biomedical and legal questions. It extracts only what the retrieved chunks state, as flat strings.

The method we reuse comes from the typing literature. Biomedical Interpretable Entity Representations (BIERs) maps biomedical mentions onto 68,304 interpretable categories linked to UMLS and reaches 84.0% on clinical entity disambiguation. It was never used for retrieval, and we use it as the type linker. Fine-Grained Entity Recognition (FIGER) showed that fine types roughly doubled relation-extraction F1. This supports the view that type information carries usable relational knowledge.

One result constrains the design. TheoremQA found that pasting theorem definitions into the prompt gave no significant boost, because models fail to apply abstract statements to concrete problems. Type-level passages have exactly this abstract form. So retrieval alone should not be expected to work, which is why the explicit instantiation chain is part of the method rather than an add-on.

The generative route to unwritten knowledge also constrains the design. COMET generates commonsense tuples, and Unsupervised Commonsense Question Answering with Self-Talk has models ask and answer their own clarification questions. Self-Talk's clarifications were judged irrelevant 24.7% of the time and nonsensical 19.9% of the time. We therefore treat generation only as a last resort for premises that are unwritten at every level of the hierarchy.

Research Program

Premise audit. Before building anything, we run a study to decide whether the idea has a basis. We take roughly 300 questions from MedQA-USMLE and MedMCQA that a strong retrieval baseline gets wrong. For each question, a clinician writes the minimal premises needed to answer it. Annotators then search a medical textbook and PubMed-abstract corpus for each premise at three levels:

  1. under the instance name,
  2. under each successive UMLS ancestor of the entity,
  3. and if found nowhere, the premise is marked unwritten.

The resulting distribution over levels is the "reporting level" of each premise and is a finding in its own right. We predict that routine, mundane premises (class contraindications, default mechanisms, standard procedural steps) sit at higher levels, while distinctive instance facts sit at the instance level. This would be a domain analogue of the pattern Shwartz and Choi found in general text.

Retriever. The retriever has four steps:

  1. Question entities are linked to fine types with a BIER-style encoder, producing a path through the ontology from the instance to its root.
  2. For each entity and required relation, the system retrieves passages at the instance level. A small verifier, a natural-language-inference model scoring whether a passage supports a relation, checks whether any passage supports it.
  3. If none does, the query is rewritten with the parent type's canonical name and the process repeats upward. It stops at the most specific supporting ancestor, with a cap on depth.
  4. Because inheritance has exceptions (some members of a drug class lack the class property), the system also runs an exception check. It searches instance-level text for statements that contradict the inherited property and lets such statements override it.

Generator and fallback. The generator is prompted to write the inheritance chain explicitly and to cite the passage used at each step. The fallback applies to premises unsupported at every level. The model may generate a candidate premise, but only in type-level form and only about the entity's linked ancestors. That candidate is then treated as a query rather than as evidence, so generated text is never trusted without retrieval support.

Secondary setting. NLPEC with the CMeKG hierarchy is a second setting. Its purpose is to check whether the effect depends on UMLS specifically.

Baselines

The naive reference points come first. The closed-book reference is the same generator with chain-of-thought and self-consistency, following Singhal et al. That paper reports 60.2% on MedQA-USMLE, 62.7% on MedMCQA, and 78.2% on PubMedQA for Codex with 5-shot chain-of-thought over 100 sampled paths. It also reports 62.5% on MedQA for Llama-2 70B. Those numbers came from older generators. We will rerun the protocol with our generator so that every comparison shares one model, one prompt budget, and one number of samples. The naive RAG reference is BM25 plus dense retrieval over the same corpus, with the same top-k and the same context budget. For NLPEC, the published point of comparison is KMQA at 61.8% accuracy, and we also rerun a KMQA-style baseline that injects knowledge-graph triples as pseudo-sentences.

The strongest structural competitors are HGRAG and HiRAG, run on our corpus with the same generator. HiRAG is the most serious of these. Its summary layers are its answer to the need for abstract knowledge, and it reports an 87.6% GPT-4o win rate over naive RAG on UltraDomain. For HGRAG, the file lists no MedQA or MedMCQA result. For HiRAG, we found no reported result on Lacuna for MedQA-USMLE or MedMCQA. Both will be run by us with equal indexing budgets, measured in tokens spent building each index.

Two ablations isolate the key ingredient. The first replaces ontology ancestors with ancestors of matched frequency chosen at random, and with a fixed lift of one level. The second removes the instantiation chain. The most important baseline is model-generated abstraction, in which the generator is prompted to name each entity's category and retrieval then runs on that name. It uses the same verifier and the same depth cap, so the only difference from our method is where the types come from.

Beating the baselines means two things. The first is higher accuracy than the best of these on MedQA and MedMCQA, significant under paired bootstrap tests. The second is higher premise recall on the audited set, measured as the fraction of annotated premises present in retrieved evidence.

Why not just…?

Why not just use a bigger model with self-consistency? Singhal et al.'s audit shows that the remaining errors are mostly knowledge errors, not reasoning errors. Shwartz and Choi show that larger text-trained models amplify reporting bias rather than correct it. Still, modern models may know drug classes parametrically. Our closed-book baseline, stratified by how often each entity appears in the corpus, measures how much headroom remains. If closed-book accuracy on head entities matches our method, we will report the gain only on tail entities, where we expect it to hold.

Why not just let the model name the category and retrieve on that? This is the real threat. If the generator reliably knows each entity's class, ontology lookup adds nothing. Our prediction is that model-named classes fail for exactly the rare entities where reporting bias is strongest, since the model learned from the same biased text. The matched ablation settles this. If model-generated abstraction matches ontology lifting on tail entities too, the method contribution collapses into prompting. The paper's contribution then becomes the premise audit and the finding that the reporting level is predictable, and we would say so.

Why not just use hierarchical graph RAG like HiRAG? HiRAG's upper layers are LLM summaries of what extraction already found. If a class-level fact appears only in a textbook chapter about the class, it is recoverable only when clustering happens to group the right instances under that class. Premise recall on the audited set tests this directly. If HiRAG recovers type-level premises at a comparable rate, curated hierarchies offer no advantage over induced ones, and that would count against us.

Why not just inject the knowledge graph, as KMQA does? KMQA already did this and still left 44% of errors in the "absent" category. Triples also lack the discourse context in which exceptions and qualifications appear. We include the KMQA-style baseline on NLPEC to show whether lifting through the type hierarchy recovers premises within that absent category.

Decisive Checks

The first decisive check is the premise audit. If fewer than about one in five instance-absent premises are found at any type ancestor, the central hypothesis fails. We would then stop the method work and publish the reporting-level distribution as a negative result.

The second check is the matched comparison between ontology types and model-generated types, stratified by entity frequency. It decides whether the ontology matters.

The third check is the instantiation ablation. It tests the TheoremQA concern: if retrieving type-level passages helps only when the explicit inheritance chain is present, that confirms application is the bottleneck, not access.

We also report the inheritance error rate. This is the fraction of answers where an inherited property was wrong for the specific instance, measured with and without the exception check. It is the main safety risk of any inheritance-based approach in medicine.