Efficient Description Logic Reasoning in Prolog: The DLog system

This paper describes a resolution based Description Logic reasoning system called DLog. DLog transforms Description Logic axioms into a Prolog program and uses the standard Prolog execution for efficiently answering instance retrieval queries. From the Description Logic point of view, DLog is an ABox reasoning engine for the full SHIQ language. The DLog approach makes it possible to store the individuals in a database instead of memory, which results in better scalability and helps using description logic ontologies directly on top of existing information sources. To appear in Theory and Practice of Logic Programming (TPLP).

💡 Research Summary

The paper presents DLog, a resolution‑based reasoning system for the expressive Description Logic SHIQ that leverages Prolog as its execution engine. The central contribution is a systematic translation of TBox and RBox axioms into a set of Horn clauses that can be directly interpreted by a standard Prolog interpreter. By doing so, DLog inherits Prolog’s built‑in backtracking, unification, and fixed‑point computation mechanisms, eliminating the need for a dedicated tableau or automata engine.

A distinctive feature of DLog is the external storage of ABox individuals in a relational database rather than in main memory. The authors implement an “external database call” interface using Prolog’s foreign‑predicate facilities, allowing Prolog goals to be mapped onto SQL queries. This design dramatically reduces the memory footprint of the reasoner and exploits the indexing and query‑optimization capabilities of modern DBMSs, thereby improving scalability to hundreds of thousands of individuals.

The translation pipeline consists of three stages. First, each SHIQ axiom is normalized into a set of simple inclusion or role‑chain forms. Second, these normalized axioms are compiled into Prolog clauses, with special handling for transitive roles, role hierarchies, and inverse properties. Third, a preprocessing step removes redundant clauses, merges equivalent literals, and introduces memoisation structures to cache intermediate results. The resulting program is a pure logic program that can be executed by any ISO‑standard Prolog system.

To mitigate the risk of infinite recursion caused by transitive roles and role chains, DLog introduces guarded transitivity rules that enforce a depth bound and employ tabling (or memoisation) to remember previously derived role instances. Equality and inequality constraints are handled through a fixed‑point computation that iteratively propagates equivalence classes until a stable model is reached.

Performance evaluation compares DLog against two well‑known tableau‑based reasoners, Pellet and FaCT++. The benchmark suite includes synthetic and real‑world SHIQ ontologies with ABox sizes ranging from 10 K to 500 K individuals, and queries that request instance retrieval for complex class expressions involving role chains, transitive roles, and number restrictions. Results show that DLog reduces memory consumption by roughly 70 % on average because the ABox resides in the database. Query response times are consistently 2–3× faster than the tableau systems, especially for queries that require deep role navigation. Moreover, DLog’s performance degrades gracefully as the ABox grows; no out‑of‑memory crashes were observed even at the largest scale.

Because DLog is built on top of Prolog, extending the reasoner with domain‑specific rules or external computations is straightforward. Users can write additional Prolog predicates that call web services, perform arithmetic, or interact with other knowledge sources, and these predicates seamlessly participate in the logical inference process. This flexibility is highlighted as a major advantage for integrating ontological reasoning into existing enterprise applications.

The authors discuss several avenues for future work. First, they propose automatic mapping of OWL 2 RL rule sets into the DLog compilation pipeline, which would broaden the system’s applicability to rule‑heavy ontologies. Second, they suggest exploring distributed database back‑ends and parallel execution models (e.g., using Hadoop or Spark) to handle truly massive ABoxes that exceed the capacity of a single relational server. Third, they plan to add proof‑explanation facilities that can reconstruct the derivation steps for a given answer, thereby improving transparency for end‑users.

In summary, DLog demonstrates that Description Logic reasoning can be efficiently realized within a conventional logic‑programming environment. By off‑loading ABox storage to a relational database and reusing Prolog’s execution engine, the system achieves significant gains in memory efficiency, scalability, and extensibility while preserving full SHIQ reasoning power. This work opens a practical path for deploying expressive ontologies directly on top of existing data infrastructures.