🤖 AI

An Explicit World Model Based on Data-First Ontology: DaoQL Multimodal Storage Validation and Counterfactual Reasoning Evaluation

This paper proposes DaoQL, a data-first ontology that decouples deterministic knowledge into an explicit multimodal database from LLM reasoning engines, demonstrating through empirical validation that this architecture significantly enhances counterfactual decomposability and mitigates structural risks like hallucination compared to implicit neural models.

Original authors: Zhanbo Li, Shifeng Wu, Xiangjin Meng, Wenjie Cai

Published 2026-07-21

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhanbo Li, Shifeng Wu, Xiangjin Meng, Wenjie Cai

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you're trying to build a super-smart robot that can help doctors diagnose diseases or bankers spot fraud. To do this, you usually teach the robot by feeding it massive amounts of text, letting it learn patterns until it "feels" like it knows the world. This is how modern AI works: it stores its knowledge inside a giant, messy web of numbers called "neural weights." Think of it like a human brain that has memorized a billion books but can't point to a specific page to show you why it thinks something is true. The problem is, this brain is a bit of a black box. If you ask it a tricky question, it might make things up (hallucinate), it can't easily update its facts when the world changes, and it's hard to explain its reasoning. Scientists call this an "implicit world model" because the rules of the world are hidden inside the math, not written down clearly.

To fix this, a new idea called "data-first ontology" suggests we stop hiding the rules. Instead of letting the AI guess the facts, we should give it a clear, organized library where every fact is stored with a specific address, like a well-organized filing cabinet. In this setup, the AI is just the smart librarian who knows how to talk to you and solve puzzles, but the actual facts live in the library's database. This paper explores a system called DaoQL that tries to build this kind of library. It asks: What if we separate the "thinking" from the "knowing"? By putting the facts in a clear, explicit database and letting the AI just read from it, can we make the robot more honest, easier to fix, and better at answering "what if" questions?

The Paper's Big Idea: A Library vs. A Black Box

The authors of this paper argue that the current way AI works is like asking a student to memorize a whole encyclopedia in their head. If you ask, "What is the capital of France?" the student might guess correctly because they've heard it a million times. But if you ask, "What if France changed its capital to Lyon yesterday?" the student might get confused, mix up old memories, or just make up a story. They can't easily "edit" their brain to remove the old fact and insert the new one without messing up other things.

This paper proposes a different approach: The Explicit World Model. Imagine instead of a student with a memorized brain, you have a robot with a super-organized library.

The Librarian (The AI): This is the Large Language Model (LLM). It's great at understanding your questions and speaking human language.
The Library (DaoQL): This is a special database where every fact is stored clearly. It uses six building blocks: Being (a thing, like a person or a product), Def (what that thing is), Type (the category), Relation (how things connect), Contract (rules they must follow), and Version (a history of changes).

The main finding is that by moving the "hard facts" into this library and letting the AI just read from it, the system becomes much more reliable. The paper proves mathematically that this setup allows for "composable counterfactual decomposability." That's a fancy way of saying: "If you change one fact in the library, the robot can perfectly calculate how that changes the answer, without getting confused or making up new rules."

What They Actually Built and Tested

The team built a system called DaoQL to test this idea. They didn't just talk about it; they built the library and ran experiments to see how fast and accurate it was.

1. The "What-If" Test (Counterfactuals)
They ran a huge experiment with 1,250 questions across five different areas: medicine, finance, supply chains, laws, and pricing. They asked the AI to imagine changes, like "What if this patient had a different allergy?" or "What if this supplier went bankrupt?"

The Result: When the AI worked alone (just using its memory), it got the "what-if" answers right only 45% of the time. But when the AI used the DaoQL library to check the facts, it got it right 94% of the time. That's a massive jump! The library helped the AI stop guessing and start calculating based on real rules.

2. Speed and Efficiency
They also tested how fast the library could find answers. They compared DaoQL to other systems on a single computer (to keep it fair).

Graph Traversal: Finding connections between things (like "Who knows who?") took just 1.20 milliseconds. That's faster than a human can blink.
Searching for Similar Items: Finding similar items in a list took 83.1 microseconds.
Mixed Queries: When they asked a complex question that needed to look at text, numbers, and connections all at once, it took 105.8 microseconds.

3. What They Didn't Do (The "Not Yet" List)
It's important to know what this paper didn't solve. The authors are very honest about this.

No Magic Agent Yet: They built the library and the "thinking" part, but they haven't fully built the "agent" (the robot that goes out and does tasks) yet. That's still a plan for the future.
Not a Billion-Scale System: They tested this on computers with 64GB or 128GB of memory. They admit they haven't tested it on the massive scale of the entire internet yet.
Some Slow Spots: While most things were fast, searching for Chinese text was much slower than other systems (about 40 times slower in their tests), which they admit is a weakness they need to fix.
Long-Tail Problems: When they tried to run complex social network simulations (LDBC SNB), the system got very slow on the hardest questions, taking seconds or even minutes instead of milliseconds.

Why This Matters

The paper suggests that the future of reliable AI isn't about making the AI's brain bigger or more complex. Instead, it's about giving the AI a better, clearer place to store its facts.

The authors show that when you separate the "knowing" (the database) from the "thinking" (the AI), you get a system that is:

More Honest: It's harder to hallucinate when you have to look up the fact first.
Easier to Fix: If a fact is wrong, you just update the library entry. You don't have to retrain the whole AI brain.
Explainable: You can trace exactly which fact led to which answer, like following a breadcrumb trail.

The paper concludes that while this isn't a finished product ready for every company today, it proves that this "data-first" way of building AI is mathematically sound and practically faster for many tasks. It's a strong step toward robots that don't just guess, but actually know what they are talking about.

Technical Summary: An Explicit World Model Based on Data-First Ontology

1. Problem Statement

The paper identifies four structural risks inherent in Large Language Models (LLMs) when they encode "world models" implicitly within neural weights: hallucination, frozen knowledge (high update costs), poor explainability, and poor modifiability (catastrophic interference). The authors argue that these limitations stem from a fundamental operational gap: implicit models lack atomic read-by-ID and local update semantics. While existing Retrieval-Augmented Generation (RAG) and agent frameworks (e.g., LangChain, GraphRAG) separate logic from storage, they suffer from token-window compression, inter-process synchronization overhead, and fragmented audit trails, failing to provide unified atomic semantics for read, patch ( $\delta$ ), evaluation (Eval), and tracing (Trace).

2. Methodology: Data-First Ontology and DaoQL

The paper proposes a data-first ontology where the LLM acts solely as a reasoning and natural language engine, while deterministic knowledge is offloaded to an explicit, multimodal database named DaoQL.

Formal Framework: The authors define an explicit world model $W$ $W$ composed of six primitives:
1. Being: The basic entity unit (UUID-based).
2. Def: Defines fields, constraints, and relationships.
3. Type: Classifies Beings.
4. Relation: Directed edges connecting Beings.
5. Contract: Fuel-limited Rhai scripts embedded in the write path for validation.
6. Version: Hash-linked history records supporting MVCC and audit replay.
Theoretical Proofs:
- Finite Bootstrapping: Proves that the schema definition chain cannot recurse infinitely (Proposition 1).
- Strong Termination: Proves that Contracts halt within a fixed fuel limit ( $F_{max}$ ) by forbidding external I/O and write recursion (Proposition 2).
- Local Update: Demonstrates that patching a specific ID in the explicit model does not alter the state of other entities (Proposition 3), a property absent in implicit models.
- Counterfactual Decomposability: Theorem 1 establishes that under rule independence and deterministic evaluation, explicit models satisfy a sufficient condition for composable counterfactual reasoning, whereas implicit models lack this architectural guarantee (Observation 3).
System Architecture: DaoQL integrates graph, column, vector, and full-text engines into a single process to eliminate network/IPC latency. Key implementation features include:
- Direct mmap Reads: Bypassing page cache for graph nodes to reduce traversal latency.
- CSR Adjacency: Per-RelationType Compressed Sparse Row files for efficient type-filtered traversal.
- Unified BeingId: A single identifier system allowing zero-copy hybrid queries across engines.
- WAL/MVCC: Ensuring atomicity and crash consistency.

3. Key Contributions

Theory: Formal definition of an explicit world model and proofs regarding schema bootstrapping, contract termination, and the structural necessity of explicit models for composable counterfactuals.
System: Implementation of DaoQL's multimodal storage layer, featuring unified engines, direct memory mapping, and cross-engine hybrid query execution.
Evaluation: A three-tier evaluation strategy comprising microbenchmarks, competitor comparisons, and a large-scale counterfactual experiment.

4. Experimental Results

The paper presents results from an embedded, same-machine setup (Apple M-series and M4 Max), explicitly noting that comparisons with client-server competitors include protocol and serialization overhead.

Counterfactual Reasoning: In a five-domain experiment ( $n=1250$ ), DaoQL+GPT-4o achieved 94% composable counterfactual decomposability, a 49 percentage point improvement over GPT-4o alone (45%). The explicit path ensured 100% traceable reasoning chains.
Storage Performance (Microbenchmarks):
- Graph BFS: 1.20 ms (4.2–6.7× faster than Neo4j in end-to-end latency).
- HNSW Search: 83.1 µs (vs. 363.4 µs for Qdrant under same parameters).
- Hybrid Query: 105.8 µs for a Fluent query combining vector, graph, and column engines.
- Write Latency: Significant reductions in batch write times (e.g., 70% improvement in batch append) after optimizing the write path (P0) and removing page cache dependencies.
Standard Benchmarks (Exploratory):
- LDBC SNB SF1: Achieved 34/34 query coverage with zero errors. However, overall throughput was limited to 1.8 QPS due to long-tail bottlenecks in complex BI/IC queries (e.g., BI9 forum tags took ~900s).
- ANN-Benchmarks: Achieved Recall@10 ≥ 99% at thousand-level QPS (5,724 QPS at ef=200) after a "bridge-edge protection" fix.
Limitations Noted: The system is currently slower than PostgreSQL for Chinese full-text search (1.27 ms vs. 32 µs) due to the overhead of the jieba tokenizer. Concurrent write throughput drops significantly (~40%) with 16 connections, indicating a need for sharded locks.

5. Significance and Claims

The paper positions its contribution as a provable structural alternative to implicit LLM world models, rather than a claim of universal superiority over all existing systems.

Architectural Guarantee: The primary significance is the demonstration that explicit world models provide a sufficient condition for composable counterfactual decomposability, a property the authors argue is architecturally impossible for pure implicit models.
Engineering Potential: The results validate the feasibility of a single-process, multimodal storage engine that reduces hybrid query latency by eliminating cross-system overhead.
Scope of Claims: The authors explicitly distinguish between provable theory (termination, local updates, counterfactual conditions) and preliminary empirical evidence (specific latency numbers, LDBC coverage). They state that the full DaoQL-Agent runtime, KVCache graph nodes, and expert hot updates remain design-stage components or future work.
Positioning: DaoQL is presented as a complementary technology to industrial ontology platforms (like Palantir Foundry), targeting data-sovereign, medium-scale, or edge environments where tight integration of Eval/Trace semantics and write-path contracts is prioritized over federated legacy integration.

The paper concludes that while the system is not yet a production-ready replacement for enterprise-scale distributed databases, it successfully validates the theoretical premise that separating deterministic knowledge from neural weights enables auditable, modifiable, and counterfactually robust AI reasoning.