Papers for

knowledge base engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Logical facts chains reveal justified answers from questions

Semantic Chains: From Reachable Facts to Justified Answers

Abstract: How can the facts that justify an answer be found from a question and presented as a sequence of connected statements? This paper models a context as a graph of logical facts and takes as given which expressions represent each fact. A parent fact can express a relation among its subfacts, and a preserving edge allows the content of a subfact to be recovered within a full representation of its parent. Suppose a root fact justifies the full answer and a path of preserving edges leads from that root to a fact that designates an object shared by the question and the answer. Under the conditions of the model, a search starting from the objects in the question reaches the root and covers every fact in the selected expansion. The root then admits a text that forms a single link connecting the question to the full answer and justifying it. For chains with several links, the paper gives a complete enumeration of candidate orders within the stated class and specifies when the link texts jointly preserve the justification and support every transition.

Tue 10 NovComputation and Language
The gist
Finding the facts that support an answer is tricky, especially when these facts connect in complicated ways. This paper shows how to organize facts as a graph where each fact links logically to others, and how to trace from a question to the answer through this network. The authors describe how to find a clear path of related facts that together justify the answer, ensuring the chain preserves meaning at each step. This helps explain how an answer follows logically from the question in a detailed, structured way.
Open → 2611.14252v1

Language model writes facts for better two-step reasoning accuracy

Write Facts the Way Models Read Them: Lifting the Two-Hop Curse

Abstract: A language model that learns a new fact by fine-tuning can repeat it but cannot reason with it: taught that a person is a citizen of a new country, it still cannot say, without chain-of-thought, who the head of state of that person's country is. This two-hop curse is widely treated as a reasoning deficit, and the strongest knowledge editors answer it with synthesized reasoning data. We show that the reasoning is intact and the writing is wrong. Fine-tuning writes a new fact as an answer to be said, whereas the second hop reads the bridge ("that person's country") as an entity, from the middle layers on: patching the model's own representation of the entity into the bridge at those layers largely restores the second hop, yet after fine-tuning the bridge there is no closer to the new entity than before the edit. We therefore propose read-equivalent writing (Legible): one loss term makes the bridge phrase, at the layer where the second hop finishes reading it, match the model's own reading of the new entity, and keeps the same relation's other subjects unchanged. Phrases and targets come from the edited model itself, and no multi-hop training data is used. Across Qwen2.5, Llama-3 and Qwen3, Legible (I) composes learned facts more often than the model composes its own knowledge, on MQuAKE's two-hop-curse questions; (II) reaches 1.8-2.6x the bridge accuracy of CaKE, whose reasoning data composes no better than plain fine-tuning, and has the best average over composition, accuracy and locality against four families of writers; and (III) lifts the curse on RippleEdits, on the benchmark of Balesni et al., who named the curse, and at 14B.

Sun 1 NovComputation and LanguageMachine Learning
The gist
Language models can learn new facts but often struggle to combine them in two-step reasoning tasks, like connecting a person to their country's leader via the country. The paper finds that the problem isn’t that the model can’t reason, but that it stores facts in a way the model doesn’t read correctly during reasoning. The authors propose a way to rewrite facts so the model’s internal reading matches new information, improving the model’s ability to chain reasoning steps without extra data. Their approach works better than previous fine-tuning methods on several language models and benchmarks.
Open → 2611.01519v1

LLM judges show bias risks in evaluating entity alignment systems

Reliability of LLM Judges for Evaluating Entity Alignment

Abstract: Entity Alignment (EA) identifies equivalent entities across knowledge graphs and is critical for knowledge base integration and ontology merging. Evaluating EA systems at scale requires expensive expert annotation, making systematic assessment across diverse domains practically infeasible. LLM-as-judge evaluation offers a potentially scalable alternative, yet its reliability for structured prediction tasks like EA remains unstudied. We present the first systematic benchmarking study across three frontier models, three datasets, and four EA systems, using perturbation bias diagnostics, meta-evaluation across all dataset-judge-prompt combinations, and counterfactual label-flip tests. We identify anchor bias, a failure mode in which judges invert discrimination when the system's decision label is visible. Label exposure causally collapses judge discrimination (J-ROC-AUC 0.12-0.87), while a label-free protocol recovers near-ceiling capability on distinctive-name datasets (0.93-1.00) and significant recovery on biomedical pairs (0.93-0.95). Counterfactual experiments confirm causality (FSR 53-99%) and reveal a frontier model paradox: stronger judges exhibit greater label sensitivity, not less. A blinded two-annotator human evaluation (102 pairs, Cohen's kappa=0.902) confirms this mechanism directly. We release the first biomedical EA benchmark (MeSH-SNOMED CT, 15K pairs) and a reproducible auditing framework for LLM judge reliability in EA. Code and data are available at https://github.com/vaibhavalakshmiravideshik/llm-as-a-judge-entity-alignment.

Wed 7 OctArtificial Intelligence
The gist
Entity alignment helps match things that mean the same across different knowledge databases, but checking if alignment systems work well needs expert human effort that is expensive and slow. The authors tested if large language models (LLMs) can replace humans as judges in this task and found that letting LLMs see the system’s answer can confuse them, causing them to rank systems incorrectly. By hiding system labels from the LLM judges, the authors recovered reliable evaluation results. They also released a new biomedical dataset and tools to help future evaluations of alignment systems.
Open → 2610.09554v1

PathAnchor improves scientific evidence retrieval and citation accuracy

PathAnchor: Path-Structured Evidence for Scientific Agents

Abstract: Scientific agents can retrieve relevant passages yet still lose functional order, mix evidence across sources, or state conclusions that exceed the retrieved record. We introduce PathAnchor, a bounded scientific reasoning system built on path-structured evidence workspaces. Instead of treating passages or extracted concepts as independent units, the system retrieves source-linked Material-Sensor-Signal-System trajectories that preserve role, direction, and the evidence supporting each transition. A controller uses three read-only tools to search paper-specific trajectories, trace paths across candidate sources, and open exact evidence before producing a claim-cited answer and an explicit evidence boundary. On 120 single- and cross-paper flexible-sensor questions, PathAnchor scores 82.6% and leads six evaluated systems. Under a matched controller, corpus, and six-call budget, replacing unordered concept graphs with path-structured records raises source recall from 61.3% to 82.9%, increases answers whose claims all cite opened evidence from 69.2% to 90.0%, and reduces tool calls. These results show that evidence organization affects retrieval and citation completeness under fixed agent resources.

Wed 30 SeptArtificial Intelligence
The gist
Sometimes, when AI systems try to answer science questions, they mix up facts or make claims not fully supported by sources. The authors developed PathAnchor, which organizes information as linked steps keeping the order and connections clear. This helps the system find better evidence, correctly trace it back, and give answers with solid proof. Tests show PathAnchor retrieves and cites relevant sources more accurately than previous methods.
Open → 2609.38766v1

Contract memory compiler improves multi-step question answering accuracy

Contract Memory Compiler: Resolve, Then Traverse

Abstract: External memory lets language-model agents answer questions about histories too long for the answer model's context window. Updates create a harder problem than retrieving a recent fact: changing one relation can redirect a multi-hop question to records about an entity absent from the question. We study this update-dependent evidence selection problem and introduce the Contract Memory Compiler (CMC). Before seeing a question, CMC uses a language model to identify relations in the history and record where each one was stated. It applies later updates to determine the current relations, follows them from entities named in the question, and passes the corresponding original records to the answer model in one call. Thus the current state determines which evidence is read, rather than merely refreshing values in a previously selected context. To the best of our knowledge, CMC achieves state-of-the-art multi-hop accuracy on FactConsolidation, reaching 78.25% overall and 61.0% at 262K. With the extracted relations and answer model held fixed, selecting evidence before resolving updates reduces multi-hop accuracy to 21.50%. We also introduce MQuAKE-MemStream, a derived dataset of ordered memory streams built from MQuAKE-Remastered counterfactual cases.

Sat 26 SeptArtificial Intelligence
The gist
Answering questions that need many steps and rely on long histories is hard. The authors show that when the information changes, just grabbing recent updates is not enough — you need to find the right original details based on the updated facts. They built a system called Contract Memory Compiler (CMC) that looks at all changes first, figures out which pieces of the entire history really matter, and then gives only those details to the answer engine. This approach works better than older methods and leads to more accurate multi-hop question answering.
Open → 2609.32658v1

Efficient dense vector search boosts multimodal querying in knowledge graphs

Efficient Dense Vector Search within Knowledge Graph Content Embeddings

Abstract: Knowledge graphs are a core component of today's knowledge infrastructure, supporting reasoning and anchoring knowledge systems to verifiable facts. RDF stores and SPARQL engines fulfill this function, enabling a range of retrieval and inference tasks on structured knowledge. Coupling them with Language Models (LMs) extends RAG toward neurosymbolic reasoning, where structured queries gate or re-rank generative outputs. This line of reasoning requires that SPARQL evaluation natively support tensor operations on dense embeddings, enabling multimodal querying and learned similarity-based ranking to be expressed together with graph-structural constraints. This approach is feasible only if the engine can efficiently perform dense vector search. We present QLever-Unified Indexed Vector Embedding Retrieval (QUIVER), an extension to QLever that adds native support for dense vector retrieval within RDF knowledge graphs. It implements three optimizations: engine-level registration of tensor functions, vocabulary-time parsing of JSON-encoded vectors, and a virtual SERVICE that exposes a vector index inside the query. We propose two new benchmarks: an extension of Berlin Sparql Benchmark (BSBM) with text embeddings and an extension of DBpedia with image embeddings. Against the baselines, vocabulary-time parsing alone yields median speedups of up to 41.9x on BSBM and 20x on DBpedia for single-type ranking; adding an approximate nearest-neighbor index yields speedups of 355x on BSBM and 97.8x on DBpedia. The index further makes cross-modal vector joins on DBpedia feasible in seconds, whereas all non-indexed configurations time out.

Mon 21 SeptDatabases
The gist
Searching large knowledge graphs is important for finding facts and reasoning, but it can be slow with complex data like vectors from language or images. The authors improved an existing system by adding fast methods to search dense vectors inside these graphs, making it possible to quickly combine text, images, and structured data in queries. They also created new tests showing their approach can be tens to hundreds of times faster than before. Their work helps connect traditional knowledge bases with modern AI data for better and faster answers.
Open → 2609.24236v1

Chinese military news benchmark helps improve event and entity extraction

CMNIE: An Information Extraction Benchmark for Chinese Military News

Abstract: Structured extraction from Chinese military news supports intelligence analysis, decision-making, and knowledge base construction. However, existing resources provide limited support for joint informa?tion extraction in this domain, especially when events, event arguments, entities, and relations must be modeled together. We present CMNIE, an information extraction benchmark for Chinese military news. Extend?ing military-domain resources beyond document-level event annotations, CMNIE jointly annotates event triggers, event arguments, named enti?ties, and entity relations under a unified domain schema. The dataset contains 13,000 instances collected from public Chinese military news, with manual annotations for 7 event types, 10 argument roles, 7 entity types, and 8 relation types. We evaluate supervised IE models, zero-shot large language models, and fine-tuned LLM-based extraction methods on a shared test set. Experimental results show that CMNIE remains chal?lenging, especially for relation extraction and exact matching of event?argument spans; zero-shot LLMs often identify relevant semantic units but fail to match gold span boundaries exactly. CMNIE provides a stan?dardized benchmark for studying schema adherence, exact span match?ing, and joint structured extraction in specialized Chinese news.

Wed 9 SeptComputation and Language
The gist
Extracting detailed, structured information from Chinese military news articles is hard because events, people, places, and their connections all need to be understood at once. The authors created a new dataset called CMNIE with 13,000 carefully labeled news instances that identify different event types, important roles in those events, named entities, and relations between them. They tested current AI models and found the task remains difficult, especially for exact matches of event details and relationships. This dataset creates a shared challenge to help improve how machines understand complex military news in Chinese.
Open → 2609.10722v1

DBpedia triple filtering improves data precision for language generation

Validating DBpedia Triple Sets for Natural Language Generation

Abstract: We present a study of the quality of individual DBpedia triples from the perspective of Natural Language Generation, and propose and evaluate an approach for collecting entity-specific triple sets that filters out questionable triples while minimizing the loss of correct ones. We show in an evaluation against manually annotated data that with validation rules, it is possible to reach 98% precision in triple selection, and with improvements to a few Property definitions, it is possible to improve recall by 40% without harming precision.

Mon 7 SeptComputation and Language
The gist
When computers create sentences from data, the quality of that data matters a lot. This study looks closely at DBpedia, a big collection of facts, and finds ways to spot and remove unclear or wrong bits. The authors show their method picks correct facts with very high accuracy and can find many more right facts without adding mistakes. This helps make the sentences computers write based on this data clearer and more reliable.
Open → 2609.07589v1

Taxonomy creation improved by preserving structure in concept grouping

SPARROW: Scalable Taxonomy Induction via Structure-Preserving Partitioning and Constraint-Guided Merging

Abstract: Taxonomy induction aims to organize concept sets into coherent hierarchical structures. Recent LLM-based methods can induce taxonomies directly from flat term lists, avoiding the need for corpora, but degrade sharply as concept sets scale up. We argue that this degradation stems not only from context length limitations, but also from structural failures in hierarchical reasoning. To address this, we adopt a divide-and-merge paradigm that partitions concepts into smaller subsets, induces local taxonomies, and merges them into a global hierarchy. However, we identify two structural failure modes inherent to this paradigm: Structural Fragmentation, where partitioning weakens local hierarchical signals, and Parent Displacement, where locally plausible relations are misplaced in the global hierarchy. To address both, we propose SPARROW, a scalable taxonomy induction framework that combines structure-preserving spectral partitioning to retain hierarchical connectivity within each block, and constraint-guided incremental fusion that treats block-level relations as structural constraints rather than ground truth for global placement. Experiments on large-scale benchmarks show that SPARROW consistently achieves the strongest global structural quality across backbones. The code is available at https://github.com/rebeccazyr/SPARROW.

Mon 7 SeptComputation and Language
The gist
Organizing ideas into categories helps us understand relationships, but it becomes tricky when there are many concepts. The authors found that breaking concepts into smaller groups and then combining them can cause errors if the group's structure breaks down or connections get misplaced. They created SPARROW, a system that carefully groups concepts to keep these connections and uses rules to merge groups correctly. This method works better at building big, accurate idea hierarchies than previous approaches.
Open → 2609.07307v1