Paper deep dive
An Explicit World Model Based on Data-First Ontology: DaoQL Multimodal Storage Validation and Counterfactual Reasoning Evaluation
Zhanbo Li, Shifeng Wu, Xiangjin Meng, Wenjie Cai
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 90%
Last extracted: 7/21/2026, 4:49:19 AM
Summary
The paper introduces DaoQL, a data-first ontology-based multimodal database designed to create an explicit world model for Large Language Models (LLMs). It addresses structural risks in LLMs like hallucination and poor explainability by separating deterministic knowledge storage from reasoning engines. The system integrates graph, column, vector, and full-text engines within a single process, supporting atomic read/patch semantics and counterfactual reasoning. Empirical results show high performance in microbenchmarks and a 94% composable counterfactual decomposability rate when combined with GPT-4o.
Entities (14)
Relation Signals (15)
DaoQL+GPT-4o → achieves → 94% composable counterfactual decomposability
confidence 95% · DaoQL+GPT-4o achieves 94% composable counterfactual decomposability
DaoQL → implements → explicit world model
confidence 95% · This paper proposes data-first ontology... We formalize an explicit world model... The implemented system focuses on DaoQL's verified storage layer
DaoQL → uses → Type
confidence 92% · DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version
DaoQL → uses → Being
confidence 92% · DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version
DaoQL → uses → Def
confidence 92% · DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version
DaoQL → uses → Relation
confidence 92% · DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version
DaoQL → uses → Contract
confidence 92% · DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version
DaoQL → uses → Version
confidence 92% · DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large language models encode world models implicitly in neural weights, which exposes four structural risks in high-precision domains such as medicine and finance: hallucination, frozen knowledge, poor explainability, and poor modifiability. This paper proposes data-first ontology: LLMs are treated as reasoning and language engines, while deterministic knowledge is moved into an explicit multimodal database, DaoQL. We formalize an explicit world model and show that, under rule independence, deterministic evaluation, and fixed conflict resolution, explicit models provide a sufficient condition for composable counterfactual decomposability; implicit models lack atomic read/delta semantics and therefore provide no comparable architectural guarantee. The implemented system focuses on DaoQL's verified storage layer and explicit Eval path, integrating graph, column, vector, and full-text engines within one process. KVCache graph nodes, expert hot updates, and the DaoQL-Agent runtime remain future work. On an embedded same-machine setup, DaoQL reports graph BFS at 1.20 ms, HNSW at 83.1 us, and a Fluent hybrid query at 105.8 us; these results indicate engineering potential but must be interpreted with deployment-shape differences from client-server systems. Exploratory measurements on LDBC SNB SF1 and ANN-Benchmarks further show 34/34 query coverage with interactive-class queries mostly in the sub-millisecond to millisecond range, but only 1.8 QPS overall due to long-tail BI/IC queries; ANN-Benchmarks reaches Recall@10 >= 99% at thousand-level QPS after a bridge-edge protection fix. In a five-domain counterfactual experiment (n = 1250), DaoQL+GPT-4o achieves 94% composable counterfactual decomposability, 49 percentage points above GPT-4o alone. The paper explicitly separates provable structure, preliminary empirical evidence, and architectural roadmap claims.
Tags
Links
- Source: https://arxiv.org/abs/2607.17269v1
- Canonical: https://arxiv.org/abs/2607.17269v1
Trouble viewing inline? Open PDF directly →
Full Text
49,096 characters extracted from source content.
Expand or collapse full text
An Explicit World Model Based on Data-First Ontology: DaoQL Multimodal Storage Validation and Counterfactual Reasoning Evaluation Zhanbo Li, Shifeng Wu, Xiangjin Meng, Wenjie Cai Graduate Students, School of Mathematics and Statistics, Chongqing University DaoQL Project Group Contact affiliation: Guangzhou Polytechnic Normal University shifengwu@gpnu.edu.cn zhanbo.lee@hotmail.com 202506131076T@stu.cqu.edu.cn 202506131075T@stu.cqu.edu.cn (May 2026) Abstract Large language models encode world models implicitly in neural weights, which exposes four structural risks in high-precision domains such as medicine and finance: hallucination, frozen knowledge, poor explainability, and poor modifiability. This paper proposes data-first ontology: LLMs are treated as reasoning and language engines, while deterministic knowledge is moved into an explicit multimodal database, DaoQL. We formalize an explicit world model and show that, under rule independence, deterministic evaluation, and fixed conflict resolution, explicit models provide a sufficient condition for composable counterfactual decomposability; implicit models lack atomic read/δ semantics and therefore provide no comparable architectural guarantee. The implemented system focuses on DaoQL’s verified storage layer and explicit Eval path, integrating graph, column, vector, and full-text engines within one process. KVCache graph nodes, expert hot updates, and the DaoQL-Agent runtime remain future work. On an embedded same-machine setup, DaoQL reports graph BFS at 1.20 ms, HNSW at 83.1 μ , and a Fluent hybrid query at 105.8 μ ; these results indicate engineering potential but must be interpreted with deployment-shape differences from client-server systems. Exploratory measurements on LDBC SNB SF1 [15] and ANN-Benchmarks [2] further show 34/34 query coverage with interactive-class queries mostly in the sub-millisecond to millisecond range, but only 1.8 QPS overall due to long-tail BI/IC queries; ANN-Benchmarks reaches Recall@10 ≥ 99% at thousand-level QPS after a bridge-edge protection fix. In a five-domain counterfactual experiment (n=1250n=1250), DaoQL+GPT-4o achieves 94% composable counterfactual decomposability, 49 percentage points above GPT-4o alone. The paper explicitly separates provable structure, preliminary empirical evidence, and architectural roadmap claims. Keywords: data-first ontology; multimodal database; neuro-symbolic AI; world model; counterfactual reasoning; benchmark evaluation 1 Introduction Large language models (LLMs) [12, 9] show strong generalization and natural-language reasoning, but their default paradigm encodes a “world model” implicitly in billions of neural parameters [8, 13]. This tight coupling of knowledge and computation creates four structural limitations in settings that require precision and auditability: factual conflicts caused by probabilistic sampling, frozen knowledge with high update cost, weak explainability of reasoning paths [3], and poor surgical modifiability due to catastrophic interference [17]. We argue at the operational-semantics level that these limitations share one gap: implicit models lack atomic read-by-ID and local update semantics. RAG and agent frameworks such as LangChain, Hermes, and OpenClaw mitigate memory and knowledge defects by attaching vector stores or graphs to LLMs. This establishes a separation between the logic layer and the storage layer, but it still has three bottlenecks. First, token windows force lossy context compression. Second, memory retrieval and agent execution often live in separate processes, introducing synchronization and serialization overhead. Third, reasoning logs and database writes are usually recorded separately, making financial-grade auditability difficult. Existing systems do not provide read, δ, Eval, and Trace as unified atomic semantics. We propose an explicit world-model architecture guided by data-first ontology [5, 25, 27, 1]: the LLM is a reasoning and natural-language engine, while deterministic knowledge is stored in DaoQL, a multimodal database. DaoQL uses six explicit primitives - Being, Def, Type, Relation, Contract, and Version - to construct an addressable and versioned world model W. Theoretically, we formalize the operational-semantics difference between explicit and implicit models, derive a sufficient condition for composable counterfactual decomposability (Theorem 1), and analyze why single-process multimodal execution can reduce latency. Empirically, the paper focuses on the verified storage layer, explicit Eval path, and counterfactual experiment; KVCache graph nodes and the full DaoQL-Agent runtime remain design-stage components. The contributions are: 1. Theory. We define an explicit world model, prove finite Def bootstrapping, strong Contract termination, and local update, and explain why implicit models lack an architectural guarantee for composable counterfactuals. 2. System. We implement and evaluate DaoQL’s multimodal storage layer, including mmap reads, relation-type CSR adjacency, WAL/MVCC, and cross-engine hybrid queries. 3. Evaluation. We combine three-tier microbenchmarks, same-machine competitor comparisons, LDBC/ANN exploratory standard-set measurements, and a 1,250-query counterfactual experiment. Table 1: Scope of claims in this paper Layer / capability Evidence in this paper Status Explicit world-model theory Formal definitions, well-formedness, counterfactual sufficient conditions Established theoretically DaoQL storage layer Graph, column, vector, full-text, WAL/MVCC, mmap benchmarks Implemented and measured LDBC SNB / ANN sets SF1 34/34 query coverage; ANN Recall@10 curve Exploratory measurement Explicit Eval path 1,250-query counterfactual experiment Preliminary validation Memory-layer recall HNSW + Tantivy + graph benchmarks as indirect support Partially supported DaoQL-Agent runtime Design document and context mechanism Design stage KVCache graph nodes and expert hot updates Architecture roadmap Future work 2 Related Work 2.1 Knowledge Representation and Graph Databases Knowledge representation and reasoning (KRR) [16, 20, 14, 18, 24, 23, 6] aims to make entities and logic machine-operable. RDF [32] and OWL [30, 31] provide the logical foundation of the Semantic Web, but mainly describe static propositions and do not natively integrate version chains or executable behavioral semantics. Datomic [26] pioneered immutable append and “time as a first-class concern,” but its EAVT model remains a passive fact-recording model rather than an autonomous computational unit model. Property graphs such as Neo4j [19, 29] and strongly typed graph databases such as TypeDB [28] improve structured graph modeling. However, for next-generation AI world models they still face two limitations: inheritance and schema are largely static, and vector retrieval and column aggregation are not unified in the same process, causing network and serialization overhead. DaoQL addresses this design space by embedding typing, graph traversal, vector search, column aggregation, versioning, and contract checks into one storage kernel. 2.2 LLM-Augmentation and Agent Frameworks RAG systems increasingly attach external knowledge bases to LLMs. GraphRAG [4] and LightRAG [7] extract entities and relations from text and use graph topology to improve context. Yet the graph remains an external, mostly read-only augmentation component. When injected facts conflict with parameterized knowledge, systems still lack deterministic, atomic conflict resolution and counterfactual evaluation. Long-context memory systems such as MemGPT [21] manage conversation history using a virtual-memory analogy, but operate at the text-block granularity rather than as structured entities with version chains. Agent frameworks typically use LLMs as controllers and external databases such as SQLite, Chroma, or Pinecone as memory components. This is easy to engineer but fragments context, memory, and audit logs across systems. DaoQL-Agent proposes representing turns and messages as Being nodes and using graph traversal instead of lossy compaction; however, the full agent runtime is not measured in this paper. 2.3 Industrial Ontology Platforms and Standard Benchmarks Industrial Ontology platforms, exemplified by Palantir Foundry [22], use Object/Link/Action semantics to model enterprise entities and operations. They share the paper’s motivation toward explicit semantics, but typically place Ontology as a semantic mapping layer above multiple stores such as Cassandra, Elasticsearch, and JanusGraph. Their advantage is federated access to existing data infrastructure. DaoQL instead sinks Being/Type/Relation into single-process storage primitives, trading migration cost for a tighter Eval/Trace path. LDBC SNB [15] and ANN-Benchmarks [2] provide common workloads for graph and approximate nearest-neighbor systems; we use them as exploratory standard-set measurements rather than official certification. 3 Materials and Methods This section is organized as theory, implementation, and experimental design. Section 3.1 formalizes the explicit world model; Section 3.2 describes the system architecture; Section 3.3 specifies benchmarks and counterfactual evaluation. 3.1 Theory and Formal Model 3.1.1 Overview of Data-First Ontology Data-first ontology claims that a world model should consist of structured, inspectable, controllable explicit data rather than implicit weights. DaoQL realizes this through six primitives. Being is the basic entity unit and is identified by UUID. Def and Type define fields, constraints, relationships, and runtime dispatch. Relation connects Beings as directed edges. Contract is a fuel-limited Rhai script embedded in the write path. Version is a hash-linked history record that supports MVCC and audit replay. The following formal framework gives the precise definitions and proof obligations. To turn the Introduction’s “knowledge sinking” claim into testable scientific statements, this section formalizes the explicit world model and derives its structural properties; system implementation (§3.2) and experimental design (§3.3) build on this foundation. 3.1.2 Formal Definitions An implicit world model encodes knowledge in a neural network fθ:→f_θ:X [8, 13], with forward inference and global parameter updates θ↦θ′θ θ as primary operations. An explicit world model, by contrast, carries deterministic knowledge in addressable, versioned data structures. Table 2 summarizes the main symbols. Table 2: Main symbols in the theory framework Symbol Meaning ℐ,ℬ,,,ℛ,,ID,B,D,T,R,C,V Identifier and six primitive sets W=(ℬ,,,ℛ,,)W=(B,D,T,R,C,V) Explicit world-model state δ(W,p)δ(W,p) State after applying patch p to W (ϕ,W) Eval(φ,W) Evaluation of query/rule ϕφ on state W (q,W) Trace(q,W) Execution trace of query q on W FmaxF_ Contract fuel limit Definition 1 (Six Primitives). The primitives are: • Being b=(id,core,ext,history)b=(id,core,ext,history): id∈ℐid , history=[v1,…,vn]history=[v_1,…,v_n] is a version chain; • Def d=(name,fields,constraints,contracts,fsm,rel_decls)d=(name,fields,constraints,contracts,fsm,rel\_decls); • Type t=(name,parent,contracts,constraints)t=(name,parent,contracts,constraints); • Relation r=(type,src,dst,direction,ext,window)r=(type,src,dst,direction,ext,window); • Contract c=(hook,source,ast)c=(hook,source,ast); • Version v=(ts,hash,prev_hash,payload)v=(ts,hash,prev\_hash,payload). The explicit world model is W=(ℬ,,,ℛ,,)W=(B,D,T,R,C,V). Definition 2 (State Equivalence). Given a fact domain ℱF, if W1W_1 and W2W_2 agree on all observable facts in ℱF, we write W1≡ℱW2W_1 _FW_2. This structure realizes four atomic semantics: read by ID, patch update (δ), deterministic rule evaluation ( Eval), and execution tracing ( Trace). DaoQL implements them via BeingId addressing, append-only WAL, and MVCC snapshots (§3.2.3). 3.1.3 Well-Formedness and Execution Safety DaoQL adopts a “schema-as-data” design: Def is itself a Being, bootstrapped by the axiom Def DAO_DEF. We must ensure that this mechanism does not yield infinite meta-definition chains and that Contracts embedded in the write path cannot violate system termination. Proposition 1 (Finite Def Bootstrap Chain). Let axiom Def d0∈d_0 satisfy d0.core.def=d0d_0.core.def=d_0; and ∀d∈∖d0,d.core.def=d0∀ d \d_0\,\,d.core.def=d_0, ∀b∈ℬ,b.core.def∈∖d0∀ b ,\,b.core.def \d_0\. Then any ordinary Being has def-reference chain length at most 2, any ordinary Def has chain length 1, and DAO_DEF is only a controlled self-reference. Proof. For any b∈ℬb , b.core.def=d1∈∖d0b.core.def=d_1 \d_0\ and d1.core.def=d0d_1.core.def=d_0, hence b→d1→d0b→ d_1→ d_0 with chain length 2. For any d∈∖d0d \d_0\, d→d0d→ d_0 with chain length 1. Suppose an infinite chain d0→d1→d2→⋯d_0→ d_1→ d_2→·s exists: if d1≠d0d_1≠ d_0, then d1d_1 is an ordinary Def and d1.core.def=d0d_1.core.def=d_0 forces termination at d0d_0, a contradiction. ∎ Proposition 2 (Strong Contract Termination). Suppose Contract execution forbids new writes and external I/O, consumes one fuel unit per step, and is capped at FmaxF_ . Then ∀c∈∀ c , (c) Exec(c) halts within FmaxF_ steps. Proof. Use remaining fuel Φ(et)=(et) (e_t)= Fuel(e_t) as a potential function, initialized to FmaxF_ and strictly decreasing by one per step. Forbidding write recursion and external I/O excludes infinite-wait paths; by well-ordering of natural numbers, execution terminates and rolls back when fuel reaches zero, so at most FmaxF_ steps occur. ∎ Propositions 1–2 bound the metadata layer and guarantee write-path termination, supporting the DAO_DEF axiom layer and the default 10,000-step Contract fuel limit described in §3.1.1. 3.1.4 Operational Semantics: Implicit vs. Explicit Models The four LLM crises named in the Introduction can be unified at the operational-semantics level: implicit model imp=fθ,θ↦θ′O_imp=\f_θ,\,θ θ \ lacks database-style atomic read and δ. Observation 1 (Implicit Models Lack Database-Style Atomic Operations). Operationally, LLM knowledge is encoded in distributed parameters θ, with usable operations mainly fθ(x)f_θ(x) and θ↦θ′θ θ ; therefore existing LLM architectures do not provide database-isomorphic θ(id) read_θ(id) and δθ(θ,patchid) _θ(θ,patch_id), nor can precise read-by-ID and local update be system invariants. Proof. If a δθ _θ existed that updated only the fact for idid, parameters should decompose as θ=⨆idθ|idθ= _idθ|_id; but LLM weights encode semantics in a distributed manner, with no provably independent θ|idθ|_id. Fine-tuning θ′=θ−η∇θLθ =θ-η _θL is global and aligns with catastrophic interference [17]. Prompt intervention y=fθ(x′)y=f_θ(x ) changes input only, not persistent state. The assumption fails. ∎ Proposition 3 (Local Update in Explicit Models). Let W′=δ(W,p)W =δ(W,p), where the scope of p is (p)⊆id0∪r∣r.src=id0orr.dst=id0 Dom(p) \id_0\∪\r r.src=id_0\ or\ r.dst=id_0\, and the system uses BeingId addressing, append-only WAL, and MVCC snapshot reads. Then ∀b∈ℬ,b.id≠id0:W′|b≡W|b∀ b ,\,b.id≠ id_0:\,W |_b≡ W|_b. Proof. The patch does not touch other entity fields; WAL appends only version vn+1v_n+1 for id0id_0, leaving history(b)history(b), core(b)core(b), and ext(b)ext(b) unchanged for all other entities. By the definition of state equivalence, semantics on the untouched fact domain is unchanged. ∎ Observation 2 (Shared Operational Root of the Four LLM Crises). If a system has only impO_imp without read, δ, Eval, and Trace, then hallucination resistance (needs deterministic Eval), live updates (needs δ), explainability (needs Trace), and surgical edits (needs local δ) cannot simultaneously hold as architectural invariants. Proof. By Observation 1, implicit models lack local δ and atomic read. fθf_θ outputs token distributions rather than (ϕ,S)∈⊤,⊥ Eval(φ,S)∈\ , \ [11]; θ↦θ′θ θ is costly and global; internal activations cannot be reconstructed as symbolic reasoning chains. The operations required by all four properties are absent from impO_imp, hence they share one operational root. ∎ Observation 2 does not claim that every LLM failure has a single explanation; rather, in settings requiring deterministic factual judgment, local update, and audit trails, the four crises share one operational gap. Data-first ontology fills these atomic semantics through explicit structure W, forming the theoretical starting point of our architecture. 3.1.5 Counterfactual Reasoning In Pearl’s causal hierarchy, the counterfactual layer asks how conclusions would change had facts differed [23]. We operationalize this as applying patch p to explicit state S=(W,)S=(W,K) and executing (ϕ,δ(S,p)) Eval(φ,δ(S,p)), which directly matches the counterfactual protocol in §3.3. Theorem 1 (Composable Counterfactual Decomposability). Let p1,p2p_1,p_2 be patches composed of finitely many atomic update/relate operations, and let ϕφ depend on fact domain ℱϕF_φ. If δ(δ(S,p1),p2)≡ℱϕδ(δ(S,p2),p1)δ(δ(S,p_1),p_2) _F_φδ(δ(S,p_2),p_1), Eval is deterministic, and rule conflicts have fixed priority, then (ϕ,δ(δ(S,p1),p2))=(ϕ,δ(S,p1⊕p2)). Eval(φ,δ(δ(S,p_1),p_2))= Eval(φ,δ(S,p_1 p_2)). (1) Proof. Let S2=δ(δ(S,p1),p2)S_2=δ(δ(S,p_1),p_2) and S12=δ(S,p1⊕p2)S_12=δ(S,p_1 p_2). By patch commutativity and fixed conflict resolution, S2≡ℱϕS12S_2 _F_φS_12. Since ϕφ depends only on ℱϕF_φ, evaluation is a deterministic function gϕ(S|ℱϕ)g_φ(S|_F_φ), hence (ϕ,S2)=(ϕ,S12) Eval(φ,S_2)= Eval(φ,S_12). ∎ Observation 3 (No Architectural Guarantee of Composable Counterfactuals for Implicit Models). LLM implicit evaluation ϕ^(ℓ,S)=Sample(fθ(ℓ⊕encode(S))) φ( ,S)=Sample(f_θ( encode(S))) cannot architecturally guarantee that semantically equivalent phrasings yield the same conclusion, that composed edits satisfy Theorem 1, or that edit order is immaterial. Proof. On the explicit path, semantically equivalent phrasings ℓ1,ℓ2 _1, _2 map to the same patch p=π(ℓ1)=π(ℓ2)p=π( _1)=π( _2); on the implicit path, ℓ1≠ℓ2 _1≠ _2 may yield Pθ(y|ℓ1,S)≠Pθ(y|ℓ2,S)P_θ(y| _1,S)≠ P_θ(y| _2,S). Implicit models lack δ, so comparable structured states S2S_2 and S12S_12 cannot be constructed; prompt order changes attention context, so commutativity has no architectural guarantee. ∎ Theorem 1 shows that under rule independence and deterministic Eval, composable counterfactual decomposability is a provable structural property; Observation 3 explains why the pure LLM path lacks an equivalent guarantee. Together they set the theoretical expectations for §4.1. 3.1.6 Neuro-Symbolic Division of Labor and Performance Mechanism In a neuro-symbolic architecture, deterministic knowledge G⊆G lives on the symbolic side; queries are evaluated by (ϕ,) Eval(φ,S) and the LLM only naturalizes y=πnl(r)y= _nl(r). The executor records =⟨op1,…,opm⟩ Trace= op_1,…,op_m with Being/Relation IDs accessed at each step, so conclusions trace back to explicit reasoning paths—explaining 100% traceability in the counterfactual experiment. This property fails when the LLM bypasses Eval and generates directly. For performance, hybrid query q=qvec∘qgraph∘qcolq=q_vec q_graph q_col in a multi-stack architecture requires k cross-process calls. With per-call network/IPC latency Tnet,i≥τnet>0T_net,i≥ _net>0, Tmulti−Tmono≥kτnet−Tdispatch,T_multi-T_mono≥ k _net-T_dispatch, (2) where Tmulti=∑i(Tnet,i+Tser,i+Tquery,i)T_multi= _i(T_net,i+T_ser,i+T_query,i) and Tmono=Tvec+Tgraph+Tcol+TdispatchT_mono=T_vec+T_graph+T_col+T_dispatch. In DaoQL’s single process Tnet=0T_net=0, eliminating cross-system overhead on the order of kτnetk _net; this inequality explains low hybrid-query latency but does not imply DaoQL is asymptotically optimal on all algorithms. For graph traversal, DaoQL pointer-adjacency BFS on subgraph G′=(V′,E′)G =(V ,E ) runs in O(|V′|+|E′|)O(|V |+|E |) because each vertex and edge is processed at most once. This shows the storage shape approximates the ideal BFS access model; measured 4.2–6.7× speedup over Neo4j (Table 8) is an engineering constant factor and must not be conflated with the complexity result. We distinguish two kinds of claims: Contract termination, local update, and Eq. (1) are provable under stated axioms; BFS 1.20 ms and 94% composable decomposability are empirical results on specific hardware and datasets, validating predictions rather than replacing theory. 3.2 System Architecture and Implementation 3.2.1 Five-Layer Integrated Architecture Figure 1 illustrates how an explicit world model could grow into a full neuro-symbolic system. The empirically verified core in this paper is the storage layer and the explicit Eval path; several memory, learning, inference, and application components remain roadmap items. • Storage layer. DaoQL integrates graph, column, vector, and full-text engines in one process with a unified BeingId. WAL and MVCC provide atomicity and crash consistency. • Memory layer. Session lifecycle and historical recall are intended to use HNSW, Tantivy, and graph traversal. These components are individually measured, but the full agent memory layer is not. • Learning layer. Expert and router hot updates are planned architecture goals. • Inference layer. A customized LLM can in principle navigate semantically related KVCache graph nodes, but this remains a planned direction. • Application layer. DaoQL-Agent exposes FSM-driven workflows and tool-safety Contracts, but the runtime is design-stage. ApplicationDaoQL-Agentdesign stage Application LayerInferenceV4 + Attentionplanned Inference LayerLearningExpert/RouterplannedMemoryhybrid recallpartially verified Memory / LearningStorage DaoQL: Graph + Column + Vector + Fulltext + WAL/MVCC (unified BeingId) Storage Layer Data flow: user query → hybrid recall → mmap zero-copy load → inference → atomic WAL commit Figure 1: Five-layer neuro-symbolic architecture and verification scope. The storage layer is measured in the current configuration; the memory layer is indirectly supported by component benchmarks; application, inference, and learning layers are future targets. In the complete design, a user query triggers hybrid recall, locates relevant Beings and KVCache offsets, loads them through mmap, invokes inference, and writes results atomically through the WAL. The verified part is concentrated in storage: the current configuration bypasses PageCache/ArcSwap on graph reads, and WAL recovery for 10K entries takes 219.6 μ . DSL ParserFluent API Query Layer (Tables 6–7)Write CoordinatorCross-Engine Executor Execution LayerGraph EngineColumn EngineVector EngineIndex / Fulltext Storage Layer (Table 5)Physical Layer: WAL + direct mmap read path + version chain Physical Layer Figure 2: DaoQL’s internal four-layer engine architecture and its mapping to the three-tier benchmark suite. The current measurement introduces direct mmap reads in the physical layer and P0#1/#2/#5 write-path optimizations. 3.2.2 Graph-Driven Agent Context and Direct mmap Reads External agent frameworks usually compress old messages because of token-window limits. DaoQL-Agent instead models interaction history as graph nodes connected by relations such as HAS_TURN and HAS_MESSAGE. A ContextBuilder can traverse from a session node to assemble context. The measured graph traversal latency (BFS 1.20 ms and DSL Chain Depth30 79.3 μ ) supports the feasibility of this design, but not a complete agent-system claim. For graph-heavy workloads, the current configuration changes NodeStore/EdgeStore reads from pagecache + ArcSwap to direct mmap pointer reads. It further maintains a per-RelationType CSR adjacency file (csr_:04x.bin) so type-filtered BFS and triangle-count queries can read neighbors without scanning edge chains. This reduces edge write-read latency from 397.6 ns to 304.4 ns and BFS fanout4 depth5 from 1.97 ms to 1.20 ms. In LDBC SNB, IC14 drops from the 30 s range to 0.64 ms. 3.3 Experimental Design 3.3.1 Environment and Datasets Microbenchmarks and same-machine competitor comparisons run on an Apple M-series machine with 64 GB LPDDR5 and NVMe SSD (∼ 3.5 GB/s), Rust 1.94.1, Criterion.rs release mode, and median reporting. LDBC SNB and ANN-Benchmarks exploratory runs use Apple M4 Max, 128 GB LPDDR5, and NVMe SSD (∼ 7 GB/s), DaoQL v1.1.0 release build. The two groups are reported separately and are not merged into a single ranking. • XY-ERP: synthetic ERP data, about 1.9M entities covering orders, BOM, and supplier links. • YAGO4: public knowledge graph, about 3.4M entities, used for reproducibility checks. • Synthetic microbenchmarks: 10K vectors (64D, Cosine, M=16M=16, ef=100) and 10K Chinese documents. • LDBC SNB SF1: about 1M Persons, 37M edges, and 34 IC/BI queries, using a custom driver rather than official submission. • ANN-Benchmarks: random-s-100-euclidean, 90K × 100 training vectors, 10K × 100 test vectors. Table 3: Fairness boundaries of performance comparisons Dimension Setting Interpretation boundary Deployment shape DaoQL embedded; competitors often client-server Ratios include process, protocol, and serialization costs Data scale 10K–100K microbenchmarks; 1.9M business entities Not evidence for billion-scale workloads Cache state Criterion release median; same-machine repeated runs Hot-cache and tail latency need separation HNSW parameters 10K vectors, 64D, M=16M=16, ef=100 Only this parameter range Hybrid query Single-process vector → graph → column No full multi-stack RAG baseline Standard sets M4 Max 128GB vs M-series 64GB Reported separately, not merged LDBC status 34/34 queries run Not official LDBC certification 3.3.2 Benchmark and Counterfactual Protocols We use three benchmark tiers: sub-crate engine microbenchmarks, Fluent API microbenchmarks, and DSL end-to-end microbenchmarks. Business stress tests include engine, Fluent, and DSL suites. Configuration ablation compares the previous pagecache/ArcSwap configuration with the current mmap + P0 write-path configuration. LDBC SNB uses SF1, 8 workers, 30 s warmup, 600 s measurement, and 1 GB page cache. ANN-Benchmarks reports QPS and Recall@10 for ef_search ∈50,100,200,400,800,1600∈\50,100,200,400,800,1600\. The counterfactual experiment compares GPT-4o with DaoQL+GPT-4o. It covers five domains - medical decision, financial credit, supply-chain risk, regulatory compliance, and dynamic pricing - with 50 cases per domain and five natural-language paraphrases per case, for 1,250 queries. Metrics include answer consistency, safety, reasoning-chain traceability, update correctness after new information, counterfactual stability, and composable counterfactual decomposability. The materials describe domains, scale, metrics, and partial ground-truth rules, but not full prompts, temperature, scoring protocol, or per-case error logs; therefore we treat the result as preliminary evidence. 4 Results and Analysis We evaluate four aspects: counterfactual robustness, storage performance, same-machine and standard-set benchmarks, and system-level primitive composition. Values in Sections 4.2–4.3 use the M-series 64 GB platform; Section 4.4 uses the M4 Max 128 GB platform. All DaoQL measurements use real engine calls and no mock or stub paths. 4.1 Counterfactual Consistency This experiment tests the prediction of Section 3.1.5: if natural language maps to a patch and executes (ϕ,δ(S,p)) Eval(φ,δ(S,p)), composed changes should satisfy Eq. 1; GPT-4o alone lacks δ and structured state. Table 4: Counterfactual consistency experiment across five domains (n=1250n=1250) Metric GPT-4o DaoQL+GPT-4o Gain Answer consistency 71% 97% +26% Safety 79% 95% +16% Traceable reasoning chain — 100% — Correct update after new information 61% 100% +39% Counterfactual stability 58% 96% +38% Composable counterfactual decomposability 45% 94% +49% The gap between 94% and 45% on composable decomposability is consistent with Theorem 1 and Observation 3. The remaining 6% failures in the explicit path are attributed in the source materials to parsing errors, under-encoded rules, or DSL boundaries; without per-case error logs, we do not further decompose the failure modes quantitatively. 4.2 Three-Tier Microbenchmarks and Ablation Tables 5–7 compare the previous configuration with the current mmap read path and P0 write-path optimizations. Table 5: Engine-level ablation: previous vs. current configuration Benchmark Previous Current Change graph / node_store_alloc_1000 10.81 μ 7.17 μ +34% graph / node_store_write_read 1.86 μ 1.24 μ +33% graph / edge_store_write_read 397.6 ns 304.4 ns +23% column / raw_append_1000 9.03 ms 4.16 ms +54% column / projected_scan_10000 377.2 μ 221.7 μ +41% write / append_single 16.70 μ 4.74 μ +72% write / append_batch_10000 50.0 ms 14.91 ms +70% vector / hnsw_search_k10 95.4 μ 61.3 μ +36% vector / persistence_roundtrip 11.13 ms 1.66 ms +85% lookup (B+Tree) 253.3 ns 160.7 ns +37% Table 6: Fluent API microbenchmark ablation Benchmark Previous Current Change graph_write_and_traverse 18.26 μ 16.57 μ +9% column_write_and_scan 389.4 μ 374.4 μ +4% vector_search 110.6 μ 98.4 μ +11% fulltext_search 482.0 μ 415.6 μ +14% index_uuid_lookup 178.1 ns 186.9 ns −-5% Table 7: DSL microbenchmark ablation Benchmark Previous Current Change graph_traversal / 1k_depth3 25.27 μ 21.40 μ +15% combined / material_order 46.16 μ 36.54 μ +21% column_aggregate / 5k_groupby 1.20 ms 1.11 ms +8% graph_node_lookup / 1k_full 3.52 μ 3.17 μ +10% The largest gains come from removing per-row flushes and bypassing pagecache/ArcSwap on graph reads. Improvements attenuate at the Fluent and DSL layers, indicating that wrapper overhead and Being assembly remain optimization targets. 4.3 Competitor Comparison and Fairness Boundaries Table 8 summarizes same-machine results. Because DaoQL is embedded while most competitors are client-server systems, these are engineering end-to-end comparisons rather than pure kernel comparisons. Table 8: DaoQL current configuration vs. best observed competitor Capability DaoQL Best comparator Observation Point lookup 0.38 μ RocksDB ∼ 1 μ Embedded low latency Full BFS traversal 1.20 ms Neo4j 5–8 ms Lower end-to-end latency HNSW k=10 83.1 μ Qdrant 363.4 μ Leads under current parameters Column SUM 100K 362.9 μ ClickHouse ∼ 1 ms Leads at current scale Batch write 1.75 μ /row PostgreSQL 9.0 μ /row Embedded low latency Chinese full text 10K 1.27 ms PostgreSQL tsvector 32 μ DaoQL is ∼ 40× slower Cross-engine hybrid query 105.8 μ No direct comparator Missing multi-stack baseline Table 9: HNSW head-to-head: DaoQL vs. Qdrant 1.16, same machine and parameters System HNSW k=10 Brute Force k=10 SIMD DaoQL current 83.1 μ 269.0 μ 8×f32 DaoQL previous 148.4 μ 388.3 μ 8×f32 Qdrant 1.16 363.4 μ 283.4 μ 16×f32 The full-text result is an explicit weakness: Tantivy+jieba at 1.27 ms is much slower than PostgreSQL’s simple tsvector configuration at 32 μ , largely because jieba performs Chinese segmentation while the simple baseline does not. This should be treated as a limitation rather than hidden in aggregate performance claims. 4.4 Standard-Set Exploratory Measurements LDBC SNB SF1. DaoQL runs all 34 IC/BI queries on SF1 with zero errors under an 8-worker, 600 s run. RelationType CSR adjacency improves type-filtered traversal and triangle-count workloads. Representative results appear in Table 10. IC-style entity lookup and bounded traversal are generally interactive, but IC6/IC10, BI4, and BI9 remain severe long-tail bottlenecks. Overall throughput is only 1.8 QPS, so SNB BI workloads are not an advantage claim. Table 10: Representative LDBC SNB SF1 latencies (DaoQL v1.1.0, M4 Max) Class Query P50 (ms) P95 (ms) Interpretation IC IC1 profile 0.26 7.00 Interactive lookup IC IC2/IC8 recent messages/comments 0.16 0.36 Interactive IC IC13 shortest path 0.05 2.88 Multi-hop traversal IC IC3 recommendation 1.74 10.13 Acceptable IC IC6/IC10 thread/recommendation ∼ 18,900 ∼ 26,000 Long-tail bottleneck BI BI8 social circle 7.98 59.28 Moderate BI BI12/BI17 triangles 4,813/5,222 8,288/8,708 Improved but slow BI BI4 hot forums 21,225 31,483 Long-tail bottleneck BI BI9 forum tags 908,271 969,790 Extreme long tail Overall 34/34 coverage, 0 errors 1.8 QPS Dragged by slow queries ANN-Benchmarks. On random-s-100-euclidean, DaoQL HNSW with M=32M=32, M0=64M_0=64, and ef_construction=200 reports the curve in Table 11. At ef_search=200, Recall@10 is 99.3% at 5,724 QPS. The v1.1.0 bridge-edge protection fix raises Recall@200 from about 32% to above 99%, so correctness is the main result. Public hnswlib/FAISS numbers come from different hardware and are not used as same-machine wins. Table 11: ANN-Benchmarks random-s-100-euclidean (DaoQL v1.1.0) ef_search QPS Recall@10 Zero-recall queries 50 19,001 94.4% 511/10000 100 12,225 97.4% 218/10000 200 5,724 99.3% 42/10000 400 3,051 99.9% 2/10000 800 1,529 100.0% 0/10000 1600 708 100.0% 0/10000 4.5 Business Stress Tests and Hybrid Queries Table 12: xy_erp_stress engine-level results Scenario Scale Current Change BFS Fanout4 Depth5 1,365 nodes 1.20 ms +39% Order Status Chain 30 hops 2.03 ms +27% Hybrid vector → graph → column 10K 119.09 μ +14% Write Batch With-Vector 16t×10K 1,009.2 ms +14% WAL Recovery 10K 219.6 μ +20% Table 13: Fluent API stress tests: BOM traversal and batch write Scenario Previous Current Gain Chain Depth5 Skip Ext 19.0 μ 14.1 μ +26% Chain Depth30 144.5 μ 129.5 μ +10% Tree Fanout4 Depth5 6.45 ms 5.45 ms +16% Raw Engine BFS Fanout4 Depth5 1.82 ms 1.23 ms +32% Write Batch 1K No Embed 46.9 ms 23.7 ms +49% Hybrid Query 108.1 μ 105.8 μ +2% Table 14: DSL stress tests: BOM traversal and mutation Scenario Previous Current Gain Chain Depth30 111.7 μ 79.3 μ +29% Tree Fanout4 Depth5 3.59 ms 2.99 ms +17% Write Batch 1K No-Vec 81.5 ms 25.1 ms +69% Mutation No-Vec 1K 22.16 ms 8.58 ms +61% The hybrid query demonstrates the promise of a shared BeingId in one process, but because we do not provide a Neo4j+Qdrant+ClickHouse multi-stack RAG baseline, it is reported as an architectural potential rather than a completed cross-system victory. 4.6 Composite Business Scenarios DaoQL-Edu integration tests validate Being, Def, Relation, and Version composition in five representative scenarios. Table 15: Unit-test-driven composite scenarios Scenario Question Engine path Result Sales report Order total / filtered SUM Column fast path + SIMD 1M rows, 3.4 μ Risk detection Similar trade + linked account Vector → graph → column non-empty result Recommendation Similar user + influencer ranking Vector + graph + column priority=80.0 Version replay Entity price history Version chain + MVCC old version preserved Batch consistency 100 Beings + chain relations WAL + BFS + aggregate node count matches 4.7 Optimization Stability Table 16: Configuration-level ablation and stability Configuration Baseline Feature Early unified read path +O-1–O-4 Establishes unified index and read baseline warm cache / BQ +warm_cache, BQ Point lookup improves but graph traversal regresses pagecache + ArcSwap +ArcSwap, pagecache batch Batch improves but single write/HNSW/Fluent write regress mmap + P0 write optimization +mmap, P0#1/#2/#5 Current configuration with positive metrics The pagecache/ArcSwap design improved some batch paths but introduced traversal and single-write regressions. The current mmap + P0 write configuration restores read, write, and vector paths simultaneously. 5 Discussion 5.1 Theory-Design-Experiment Closure Table 17: Theory, design, and experiment closure Theory DaoQL design Prediction Status Prop. 1 DAO_DEF axiom layer Schema cannot recurse forever Theoretical closure Prop. 2 Fuel + sandbox Write path does not hang Theoretical closure Obs. 1 BeingId explicitness LLM has no local update guarantee Counterfactual comparison Prop. 3 WAL + MVCC Single update does not spread Version-chain tests Thm. 1 Deterministic DSL Eval High composable consistency 94% Obs. 3 GPT-4o baseline Prompt-only path is unstable 45% Eq. 2 Single-process engines Low hybrid latency 105.8 μ BFS complexity mmap pointer adjacency Constant-factor advantage 1.20 ms This table separates proofs from measurements. For example, O(|V′|+|E′|)O(|V |+|E |) BFS complexity does not imply a 4.2× Neo4j speedup; the latter is an engineering constant-factor measurement on one setup. 5.2 Architectural Verification Status Table 18: Architectural decisions and current verification status Decision Measurement evidence Status Join-free graph engine BFS 1.20 ms, 4.2–6.7× Neo4j Verified Direct mmap read path edge 304.4 ns, BFS +39% Verified Relation-type CSR adjacency LDBC IC14 0.64 ms, BI12/17 improved Verified ProjectedLayer + SIMD column SUM 362.9 μ , 2.8× ClickHouse Verified BeingId zero-copy across engines Hybrid 105.8 μ Verified WAL crash consistency Recovery 10K 219.6 μ Verified KVCache graph nodes Architecture plan Design stage Expert hot update Architecture plan Design stage DaoQL-Agent context traversal Design + BFS support Design stage 5.3 Positioning Against Industrial Ontology Platforms Industrial platforms such as Palantir Foundry demonstrate that explicit Ontology plus AI has commercial value in large enterprises and government settings. Their strengths are federated data integration, low-code Agent Studio, and a mature ecosystem. DaoQL should be positioned as complementary, not as a direct replacement: it targets lighter deployment, data-sovereign environments, and write-path contracts in medium-scale or edge settings. We do not compare customer counts, TCO, or production maturity. The architectural distinction is narrower: an overlay Ontology eases legacy integration, while embedded Being/Type/Relation makes Eval and WAL audit semantics easier to close in one transaction model. 5.4 Limitations 1. Embedded vs. client-server. DaoQL avoids network overhead that competitors often include. Ratios should not be read as kernel-only superiority. 2. Scale. Most microbenchmarks are 10K–100K; billion-scale graphs or vector indexes may change relative performance. 3. Chinese full text. Tantivy+jieba is a clear weakness compared with PostgreSQL simple tsvector, although the tokenization work is not equivalent. 4. Concurrent writes. 16-connection throughput drops about 40%; sharded locks are future work. 5. Counterfactual experiment. The protocol lacks full prompts, temperature, complete scoring rules, and per-case logs; results are preliminary. 6. LDBC SNB. This is a custom-driver coverage experiment, not official certification; 1.8 QPS and BI9/IC6 long tails show immaturity on global social-network aggregation workloads. 7. ANN-Benchmarks. Only one synthetic dataset is used, public competitor QPS is cross-hardware, and pre-fix v1.0 vector numbers should not be reused. 8. Industrial-platform comparison. Palantir ecosystem maturity is not experimentally evaluated; discussion is architectural positioning only. 5.5 Future Work Priorities include optimizing LDBC SNB long-tail BI/IC query plans and caches, migrating to wider SIMD paths for vectors, adding sharded locks and Contract caching for concurrent writes, improving block-level column vectorization, implementing Fluent Being assembly zero-copy, expanding counterfactual experiments to 2,500 cases with complete scoring protocols, and validating DaoQL’s deeper integration with V4 inference. 6 Conclusion This paper addresses four structural crises caused by encoding world models implicitly in LLM weights. It proposes data-first ontology: deterministic knowledge is represented by explicit primitives in DaoQL, while the LLM serves as a language and reasoning auxiliary. The formal framework defines explicit world models, proves finite Def bootstrapping and strong Contract termination, and gives a sufficient condition for composable counterfactual decomposability. The system implementation validates the storage layer through graph, column, vector, full-text, WAL/MVCC, direct mmap reads, and cross-engine hybrid queries. On the engineering side, the current Apple M-series measurements show graph BFS at 1.20 ms, HNSW at 83.1 μ , and Fluent hybrid query at 105.8 μ . M4 Max exploratory standard-set runs add LDBC SNB 34/34 query coverage and ANN-Benchmarks Recall@10 ≥ 99% at thousand-level QPS, while also exposing SNB BI long tails and cross-hardware limits. On reasoning robustness, the five-domain counterfactual experiment reports 94% composable counterfactual decomposability for DaoQL+GPT-4o, 49 percentage points above GPT-4o alone. The paper therefore presents a theory-experiment path toward auditable, modifiable, knowledge-accumulating world models, while explicitly marking agent runtime, KVCache graph nodes, and expert hot updates as future work. References [1] AlphaProof Team (2024) AI achieves silver-medal standard solving international mathematical olympiad problems. Note: Google DeepMind Blog External Links: Link Cited by: §1. [2] M. Aumüller, E. Bernhardsson, and A. Faithfull (2020) ANN-Benchmarks: a benchmarking tool for approximate nearest neighbor algorithms. Information Systems 87, p. 101374. External Links: Document Cited by: §2.3. [3] D. Bahdanau, K. Cho, and Y. Bengio (2015) Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, External Links: Link Cited by: §1. [4] D. Edge, H. Trinh, N. Cheng, J. Bradley, A. Chao, A. Mody, S. Truitt, D. Metropolitansky, R. O. Ness, and J. Larson (2024) From local to global: a graph RAG approach to query-focused summarization. arXiv preprint arXiv:2404.16130. External Links: Link Cited by: §2.2. [5] A. d. Garcez and L. C. Lamb (2023) Neurosymbolic AI: the 3rd wave. Artificial Intelligence Review 56, p. 12387–12406. External Links: Document Cited by: §1. [6] N. Guarino (1995) Formal ontology, conceptual analysis and knowledge representation. International Journal of Human-Computer Studies 43 (5-6), p. 625–640. Cited by: §2.1. [7] Z. Guo, L. Xia, Y. Yu, T. Ao, and C. Huang (2024) LightRAG: simple and fast retrieval-augmented generation. arXiv preprint arXiv:2410.05779. External Links: Link Cited by: §2.2. [8] D. Ha and J. Schmidhuber (2018) World models. arXiv preprint arXiv:1803.10122. External Links: Link Cited by: §1, §3.1.2. [9] J. Hoffmann, S. Borgeaud, A. Mensch, E. Buchatskaya, T. Cai, E. Rutherford, D. de Las Casas, L. A. Hendricks, J. Welbl, A. Clark, et al. (2022) Training compute-optimal large language models. arXiv preprint arXiv:2203.15556. External Links: Link Cited by: §1. [10] E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, and W. Chen (2022) LoRA: low-rank adaptation of large language models. In International Conference on Learning Representations, External Links: Link Cited by: An Explicit World Model Based on Data-First Ontology: DaoQL Multimodal Storage Validation and Counterfactual Reasoning Evaluation. [11] Z. Ji, N. Lee, R. Frieske, T. Yu, D. Su, Y. Xu, E. Ishii, Y. Bang, A. Madotto, and P. Fung (2023) Survey of hallucination in natural language generation. ACM Computing Surveys 55 (12), p. 1–38. External Links: Document Cited by: §3.1.4. [12] J. Kaplan, S. McCandlish, T. Henighan, T. B. Brown, B. Chess, R. Child, S. Gray, A. Radford, J. Wu, and D. Amodei (2020) Scaling laws for neural language models. arXiv preprint arXiv:2001.08361. External Links: Link Cited by: §1. [13] Y. LeCun (2022) A path towards autonomous machine intelligence. Note: OpenReview position paper External Links: Link Cited by: §1, §3.1.2. [14] H. J. Levesque and R. J. Brachman (1985) A fundamental tradeoff in knowledge representation and reasoning. In Readings in Knowledge Representation, p. 41–70. Cited by: §2.1. [15] Linked Data Benchmark Council (2015) LDBC social network benchmark (SNB). Note: Benchmark specification External Links: Link Cited by: §2.3. [16] J. McCarthy (1959) Programs with common sense. In Proceedings of the Teddington Conference on the Mechanization of Thought Processes, p. 77–84. Cited by: §2.1. [17] M. McCloskey and N. J. Cohen (1989) Catastrophic interference in connectionist networks: the sequential learning problem. In Psychology of Learning and Motivation, Vol. 24, p. 109–165. Cited by: §1, §3.1.4. [18] M. Minsky (1975) A framework for representing knowledge. In The Psychology of Computer Vision, p. 211–277. Cited by: §2.1. [19] Neo4j Inc. (2025) Neo4j graph database. Note: Release 2025.04.0Accessed 2026-05-31 External Links: Link Cited by: §2.1. [20] A. Newell and H. A. Simon (1963) GPS, a program that simulates human thought. In Computers and Thought, p. 279–293. Cited by: §2.1. [21] C. Packer, S. Wooders, K. Lin, V. Fang, S. G. Patil, I. Stoica, and J. E. Gonzalez (2023) MemGPT: towards LLMs as operating systems. arXiv preprint arXiv:2310.08560. External Links: Link Cited by: §2.2. [22] Palantir Technologies (2024) Palantir foundry ontology. Note: Product documentation External Links: Link Cited by: §2.3. [23] J. Pearl (1988) Probabilistic reasoning in intelligent systems: networks of plausible inference. Morgan Kaufmann. Cited by: §2.1, §3.1.5. [24] M. R. Quillian (1968) Semantic memory. In Semantic Information Processing, p. 227–270. Cited by: §2.1. [25] T. Rocktäschel and S. Riedel (2017) End-to-end differentiable proving. In Advances in Neural Information Processing Systems, Cited by: §1. [26] W. Schuster (2012) Rich hickey’s Datomic embraces cloud, intelligent applications and consistency. Note: InfoQ NewsAccessed 2026-05-31 External Links: Link Cited by: §2.1. [27] L. Serafini and A. d. Garcez (2016) Logic tensor networks: deep learning and logical reasoning from data and knowledge. arXiv preprint arXiv:1606.04422. External Links: Link Cited by: §1. [28] Vaticle Ltd. (2024) TypeDB: a polymorphic database for knowledge systems. Note: Accessed 2026-05-31 External Links: Link Cited by: §2.1. [29] J. Webber (2013) Graph databases: new opportunities for connected data. O’Reilly Media. Cited by: §2.1. [30] World Wide Web Consortium (2012) OWL 2 web ontology language document overview. Technical report W3C Recommendation. External Links: Link Cited by: §2.1. [31] World Wide Web Consortium (2013) SPARQL 1.1 query language. Technical report W3C Recommendation. External Links: Link Cited by: §2.1. [32] World Wide Web Consortium (2014) RDF 1.1 concepts and abstract syntax. Technical report W3C Recommendation. External Links: Link Cited by: §2.1.