A Description Logics Tableau Reasoner in Prolog

Riccardo Zese1 , Elena Bellodi1 , Evelina Lamma1 , and Fabrizio Riguzzi2

1
Dipartimento di Ingegneria – University of Ferrara
2
Dipartimento di Matematica e Informatica – University of Ferrara
Via Saragat 1, I-44122, Ferrara, Italy
[riccardo.zese,elena.bellodi,evelina.lamma,fabrizio.riguzzi]@unife.it

Abstract. Description Logics (DLs) are gaining a widespread adoption

as the popularity of the Semantic Web increases. Traditionally, reasoning
algorithms for DLs have been implemented in procedural languages such
as Java or C++. In this paper, we present the system TRILL for “Tableau
Reasoner for descrIption Logics in proLog”. TRILL answers queries to
SHOIN (D) knowledge bases using a tableau algorithm. Prolog non-
determinism is used for easily handling non-deterministic expansion rules
that produce more than one tableau. Moreover, given a query, TRILL is
able to return instantiated explanations for the query, i.e., instantiated
minimal sets of axioms that allow the entailment of the query. The Thea2
library is exploited by TRILL for parsing ontologies and for the internal
Prolog representation of DL axioms.

Keywords: Description Logics, Tableau, Prolog, Semantic Web

1 Introduction
The Semantic Web aims at making information available in a form that is un-
derstandable by machines [9]. In order to realize this vision, the World Wide
Web Consortium has supported the development of the Web Ontology Lan-
guage (OWL), a family of knowledge representation formalisms for defining on-
tologies. OWL is based on Description Logics (DLs), a set of languages that are
restrictions of first order logic (FOL) with decidability and for some of them low
complexity. For example, the OWL DL sublanguage is based on the expressive
SHOIN (D) DL while OWL 2 corresponds to the SROIQ(D) DL [9].
In order to fully support the development of the Semantic Web, efficient DL
reasoners, such us Pellet, RacerPro, FaCT++ and HermiT, must be available
to extract implicit information from the modeled ontologies. Most DL reasoners
implement a tableau algorithm in a procedural language. However, some tableau
expansion rules are non-deterministic, requiring the developers to implement a
search strategy in an or-branching search space. Moreover, in some cases we
want to compute all explanations for a query, thus requiring the exploration of
all the non-deterministic choices done by the tableau algorithm.
In this paper, we present the system TRILL for “Tableau Reasoner for de-
scrIption Logics in proLog”, a tableau reasoner for the SHOIN (D) DL imple-
mented in Prolog. Prolog’s search strategy is exploited for taking into account
34 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

non-determinism of the tableau rules. TRILL uses the Thea2 library [27] for
parsing OWL in its various dialects. Thea2 translates OWL files into a Prolog
representation in which each axiom is mapped into a fact.
TRILL can check the consistency of a concept and the entailment of an
axiom from an ontology and return “instantiated explanations” for queries, a
non-standard reasoning service that is useful for debugging ontologies and for
performing probabilistic reasoning. Instantiated explanations record, besides the
axioms necessary to entail the query, also the individuals involved in the appli-
cation of the axioms. This service was used in [21] for doing inference from DL
knowledge bases under the probabilistic DISPONTE semantics [20].
Our ultimate aim is to use TRILL for performing probabilistic reasoning.
The availability of a Prolog implementation of a DL reasoner will also facilitate
the development of a probabilistic reasoner for integrations of probabilistic logic
programming [23] with probabilistic DLs.
In the following, section 2 briefly introduces SHOIN (D) and its translation
into predicate logic. Section 3 defines the problem we are trying to solve while
Section 4 illustrates related work. Section 5 discusses the tableau algorithm used
by TRILL and Section 6 describes TRILL’s implementation. Section 7 shows
preliminary experiments and Section 8 concludes the paper.

2 Description Logics

Description Logics (DLs) are knowledge representation formalisms that possess

nice computational properties such as decidability and/or low complexity, see
[1, 2] for excellent introductions. DLs are particularly useful for representing
ontologies and have been adopted as the basis of the Semantic Web.
While DLs can be translated into FOL, they are usually represented using a
syntax based on concepts and roles. A concept corresponds to a set of individuals
of the domain while a role corresponds to a set of couples of individuals of the
domain. We now briefly describe SHOIN (D).
Let A, R and I be sets of atomic concepts, roles and individuals, respectively.
A role is either an atomic role R ∈ R or the inverse R− of an atomic role R ∈ R.
We use R− to denote the set of all inverses of roles in R. An RBox R consists
of a finite set of transitivity axioms T rans(R), where R ∈ R, and role inclusion
axioms R ⊑ S, where R, S ∈ R ∪ R− . Concepts are defined by induction as
follows. Each C ∈ A is a concept, ⊥ and ⊤ are concepts, and if a ∈ I, then {a}
is a concept called nominal. If C, C1 and C2 are concepts and R ∈ R ∪ R− ,
then (C1 ⊓ C2 ), (C1 ⊔ C2 ), and ¬C are concepts, as well as ∃R.C, ∀R.C, ≥ nR
and ≤ nR for an integer n ≥ 0. A TBox T is a finite set of concept inclusion
axioms C ⊑ D, where C and D are concepts. We use C ≡ D to abbreviate
the conjunction of C ⊑ D and D ⊑ C. An ABox A is a finite set of concept
membership axioms a : C, role membership axioms (a, b) : R, equality axioms
a = b and inequality axioms a 6= b, where C is a concept, R ∈ R and a, b ∈ I.
A knowledge base (KB) K = (T , R, A) consists of a TBox T , an RBox R and
an ABox A. A knowledge base K is usually assigned a semantics in terms of
A Description Logics Tableau Reasoner in Prolog 35

set-theoretic interpretations and models of the form I = (∆I , ·I ) where ∆I is a

non-empty domain and ·I is the interpretation function that assigns an element
in ∆I to each a ∈ I, a subset of ∆I to each C ∈ A and a subset of ∆I × ∆I to
each R ∈ R.
The semantics of DLs can be given equivalently by converting a KB into
a predicate logic theory and then using the model-theoretic semantics of the
resulting theory. A translation of SHOIN into First-Order Logic with Counting
Quantifiers is given in the following as an extension of the one given in [24].
We assume basic knowledge of logic. In predicate logic, a concept is a unary
predicate symbol while a role is a binary predicate symbol. The translation uses
two functions πx and πy that map concept expressions to logical formulas, where
πx is given by

πx (A) = A(x) πx (¬C) = ¬πx (C)

πx ({a}) = (x = a) πx (C ⊓ D) = πx (C) ∧ πx (D)
πx (C ⊔ D) = πx (C) ∨ πx (D) πx (∃R.C) = ∃y.R(x, y) ∧ πy (C)
πx (∃R− .C) = ∃y.R(y, x) ∧ πy (C) πx (∀R.C) = ∀y.R(x, y) → πy (C)
πx (∀R− .C) = ∀y.R(y, x) → πy (C) πx (≥ nR) = ∃≥n y.R(x, y)
πx (≥ nR− ) = ∃≥n y.R(y, x) πx (≤ nR) = ∃≤n y.R(x, y)
πx (≤ nR− ) = ∃≤n y.R(y, x)

and πy is obtained from πx by replacing x with y and vice-versa. Table 1 shows

the translation of each axiom of SHOIN knowledge bases into predicate logic.

Axiom Translation
C⊑D ∀x.πx (C) → πx (D)
R⊑S ∀x, y.R(x, y) → S(x, y)
T rans(R) ∀x, y, z.R(x, y) ∧ R(y, z) → R(x, z)
a:C πa (C)
(a, b) : R R(a, b)
a=b a=b
a 6= b a 6= b

Table 1. Translation of SHOIN axioms into predicate logic.

SHOIN (D) adds to SHOIN datatype roles, i.e., roles that map an individ-
ual to an element of a datatype such as integers, floats, etc. Then new concept
definitions involving datatype roles are added that mirror those involving roles
introduced above. We also assume that we have predicates over the datatypes.
A query Q over a KB K is usually an axiom for which we want to test the
entailment from the knowledge base, written K |= Q. The entailment test may
be reduced to checking the unsatisfiability of a concept in the knowledge base,
i.e., the emptiness of the concept.
SHOIN (D) is decidable if there are no number restrictions on non-simple
roles. A role is non-simple iff it is transitive or has transitive subroles.
36 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

Given a predicate logic formula F , a substitution θ is a set of pairs x/a,

where x is a variable universally quantified in the outermost quantifier in F and
a ∈ I. The application of θ to F , indicated by F θ, is called an instantiation
of F and is obtained by replacing x with a in F and by removing x from the
external quantification for every pair x/a in θ. Formulas not containing variables
are called ground. A substitution θ is grounding for a formula F if F θ is ground.

Example 1. The following KB is inspired by the ontology people+pets [16]:

∃hasAnimal.P et ⊑ N atureLover fluffy : Cat tom : Cat Cat ⊑ P et
(kevin, fluffy) : hasAnimal (kevin, tom) : hasAnimal
It states that individuals that own an animal which is a pet are nature lovers
and that kevin owns the animals fluffy and tom. Moreover, fluffy and tom
are cats and cats are pets. The predicate logic formulas equivalent to the ax-
ioms are F1 = ∀x.∃y.hasAnimal(x, y) ∧ P et(y) → N atureLover(x), F2 =
hasAnimal(kevin, fluffy), F3 = hasAnimal(kevin, tom), F4 = Cat(fluffy), F5 =
Cat(tom) and F6 = ∀x.Cat(x) → P et(x). The query Q = kevin : N atureLover
is entailed by the KB.

3 Querying KBs in SHOIN (D)

Traditionally, a reasoning algorithm decides whether an axiom is entailed or not

by a KB by refutation: axiom E is entailed if ¬E has no model in the KB.
Besides deciding whether an axiom is entailed by a KB, we want to find also
instantiated explanations for the axiom.
The problem of finding explanations for a query has been investigated by
various authors [25, 11, 13, 7, 12]. It was called axiom pinpointing in [25] and
considered as a non-standard reasoning service useful for tracing derivations and
debugging ontologies. In particular, Schlobach and Cornet [25] define minimal
axiom sets or MinAs for short.

Definition 1 (MinA). Let K be a knowledge base and Q an axiom that follows

from it, i.e., K |= Q. We call a set M ⊆ K a minimal axiom set or MinA for Q
in K if M |= Q and it is minimal w.r.t. set inclusion.
The problem of enumerating all MinAs is called min-a-enum in [25]. All-
MinAs(Q, K) is the set of all MinAs for query Q in knowledge base K.
However, in some cases, besides All-MinAs(Q, K), we may want to know
also the individuals to which the axioms were applied. We call this problem
instantiated axiom pinpointing.
In instantiated axiom pinpointing we are interested in instantiated mini-
mal sets of axioms that entail an axiom. An instantiated axiom set is a fi-
nite set F = {(F1 , θ1 ), . . . , (Fn , θn )} where F1 , . . . , Fn are axioms contained
in K and θ1 , . . . , θn are substitutions. Given two instantiated axiom sets F =
{(F1 , θ1 ), . . . , (Fn , θn )} and E = {(E1 , δ1 ), . . . , (Em , δm )}, we say that F precedes
E, written F  E, iff, for each (Fi , θi ) ∈ F, there exists an (Ej , δj ) ∈ E and a
substitution η such that Fj θj = Ei δi η.
A Description Logics Tableau Reasoner in Prolog 37

Definition 2 (InstMinA). Let K be a knowledge base and Q an axiom that

follows from it, i.e., K |= Q. We call F = {(F1 , θ1 ), . . . , (Fn , θn )} an instantiated
minimal axiom set or InstMinA for Q in K if {F1 θ1 , . . . , Fn θn } |= Q and F is
minimal w.r.t. precedence.
Minimality w.r.t. precedence means that axioms in an InstMinA are as instan-
tiated as possible. We call inst-min-a-enum the problem of enumerating all
InstMinAs. All-InstMinAs(Q, K) is the set of all InstMinAs for the query Q
in knowledge base K.

Example 2. The query Q = kevin : N atureLover of Example 1 has two MinAs

(in predicate logic): { hasAnimal(kevin, fluffy), Cat(fluffy),
∀x.Cat(x) → P et(x), ∀x.∃y.hasAnimal(x, y) ∧ P et(y) → N atureLover(x)} and
{ hasAnimal(kevin, tom), Cat(tom), ∀x.Cat(x) → P et(x),
∀x.∃y.hasAnimal(x, y) ∧ P et(y) → N atureLover(x)}. The corresponding In-
stMinAs are {hasAnimal(kevin, fluffy), Cat(fluffy) → P et(fluffy), Cat(fluffy),
hasAnimal(kevin, fluffy) ∧ P et(fluffy) → N atureLover(kevin)} and
{ hasAnimal(kevin, tom), Cat(tom), Cat(tom) → P et(tom),
hasAnimal(kevin, tom) ∧ P et(tom) → N atureLover(kevin)}.
Instantiated axiom pinpointing is useful for a more fine-grained debugging of
the ontology: by highlighting the individuals to which axioms are applied, it
may point to parts of the ABox to be modified for repairing the KB. inst-min-
a-enum is also required to support reasoning in probabilistic DLs, in particular
in those that follow the DISPONTE probabilistic semantics [20, 19].

4 Related Work

Usually, DL reasoners implement a tableau algorithm using a procedural lan-

guage. Since some tableau expansion rules are non-determinsitic, the developers
have to implement a search strategy from scratch. Moreover, in order to solve
min-a-enum, all different ways of entailing an axiom must be found. For exam-
ple, Pellet [26] is a tableau reasoner for OWL written in Java and able to solve
min-a-enum. It computes All-MinAs(Q, K) by finding a single MinA using
the tableau algorithm and then applying the hitting set algorithm [17] to find
all the other MinAs. This is a black box method: Pellet repeatedly removes an
axiom from the KB and then computes again a MinA recording all the different
MinAs so found. Recently, BUNDLE [21] was proposed for reasoning over KBs
following the DISPONTE probabilistic semantics. BUNDLE computes the prob-
ability of queries by solving the inst-min-a-enum problem. BUNDLE is based
on Pellet’s source code and modifies it for recording the individuals to which
the axioms are applied. As in Pellet, it uses a black box method to compute
All-InstMinAs(Q, K).
Reasoners written in Prolog can exploit Prolog’s backtracking facilities for
performing the search. This has been observed in various works. In [3] the authors
proposed a tableau reasoner in Prolog for FOL based on free-variable semantic
38 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

tableaux. However, the reasoner is not tailored to DLs. SWI Prolog [28] has an
RDF and Semantic Web library but is more focused on storing and querying RDF
triples, while it has limited support for OWL reasoning. Meissner [15] presented
the implementation of a Prolog reasoner for the DL ALCN . This work was the
basis of [8], that considered ALC and improved [15] by implementing heuristic
search techniques to reduce the running time. Faizi [6] added to [8] the possibility
of returning explanations for queries but still handled only ALC.
In [10] the authors presented the KAON2 algorithm that exploits basic su-
perposition, a refutational theorem proving method for FOL with equality, and
a new inference rule, called decomposition, to reduce a SHIQ KB into a dis-
junctive datalog program, while DLog [14] is an ABox reasoning algorithm for
the SHIQ language that allows to store the content of the ABox externally
in a database and to respond to instance check and instance retrieval queries
by transforming the KB into a Prolog program. TRILL differs from these work
for the considered DL and from DLog for the capability of answering general
queries.

5 The Tableau Algorithm

A tableau is an ABox. It can also be seen as a graph G where each node represents
an individual a and is labeled with the set of concepts L(a) it belongs to. Each
edge ha, bi in the graph is labeled with the set of roles L(ha, bi) to which the
couple (a, b) belongs. A tableau algorithm proves an axiom by refutation: it
starts from a tableau that contains the negation of the axiom and applies the
tableau expansion rules. For example, if the query is a class assertion, C(a), we
add ¬C to the label of a. If we want to test the emptyness (inconsistency) of a
concept C, we add a new anonymous node a to the tableau and add C to the
label of a. The axiom C ⊑ D can be proved by showing that C ⊓ ¬D is empty.
A tableau algorithm repeatedly applies a set of consistency preserving tableau
expansion rules until a clash (i.e., a contradiction) is detected or a clash-free
graph is found to which no more rules are applicable. A clash is, for example,
a concept C and a node a where C and ¬C are present in the label of a, i.e.
{C, ¬C} ⊆ L(a). If no clashes are found, the tableau represents a model for the
negation of the query, which is thus not entailed.
In TRILL we use the tableau expansion rules for SHOIN (D) shown in
Figure 1 that are similar to those of Pellet [11]. Each expansion rule updates as
well a tracing function τ , which associates sets of axioms with labels of nodes
and edges. It maps couples (concept, individual) or (role, couple of individuals)
to a fragment of the knowledge base K. τ is initialized as the empty set for all
the elements of its domain except for τ (C, a) and τ (R, ha, bi) to which the values
{a : C} and {(a, b) : R} are assigned if a : C and (a, b) : R are in the ABox
respectively. The output of the tableau algorithm is a set S of axioms that is a
fragment of K from which the query is entailed.
For ensuring the termination of the algorithm, TRILL, as Pellet, uses a spe-
cial condition known as blocking [11]. In a tableau a node x can be a nominal
A Description Logics Tableau Reasoner in Prolog 39

node if its label L(x) contains a nominal or a blockable node otherwise. If there is
an edge e = hx, yi then y is a successor of x and x is a predecessor of y. Ancestor
is the transitive closure of predecessor while descendant is the transitive closure
of successor. A node y is called an R-neighbour of a node x if y is a successor of
x and R ∈ L(hx, yi), where R ∈ R.
An R-neighbour y of x is safe if (i) x is blockable or if (ii) x is a nominal
node and y is not blocked. Finally, a node x is blocked if it has ancestors x0 , y
and y0 such that all the following conditions are true: (1) x is a successor of x0
and y is a successor of y0 , (2) y, x and all nodes on the path from y to x are
blockable, (3) L(x) = L(y) and L(x0 ) = L(y0 ), (4) L(hx0 , xi) = L(hy0 , yi). In
this case, we say that y blocks x. A node is blocked also if it is blockable and all
its predecessors are blocked; if the predecessor of a safe node x is blocked, then
we say that x is indirectly blocked.
Since we want to solve also the inst-min-a-enum problem, we modified the
tableau expansion rules of Pellet to return a set of pairs (axiom, substitution)
instead of a set of axioms. The tracing function τ now stores, together with
information regarding concepts and roles, also information concerning individ-
uals involved in the expansion rules, which will be returned at the end of the
derivation process together with the axioms. In Figure 1, (A ⊑ D, a) is the abbre-
viation of (A ⊑ D, {x/a}), (R ⊑ S, a) of (R ⊑ S, {x/a}), (R ⊑ S, a, b) of (R ⊑
S, {x/a, y/b}), (Trans(R), a, b) of (Trans(R), {x/a, y/b}) and (Trans(R), a, b, c)
of (Trans(R), {x/a, y/b, z/c}), with a, b, c individuals and x, y, z variables con-
tained in the logical translation of the axioms (Table 1). The most important
modifications of Pellet’s tableau algorithm are in the rules → ∀+ and → ∀. For
rule → ∀+ , we record in the explanation a transitivity axiom for the role R in
which only two individuals, those connected by the super role S, are involved.
For rule → ∀, we make a distinction between the case in which ∀S1 .C was added
to L(a1 ) by a chain of applications of → ∀+ or not. In the first case, we fully
instantiate the transitivity and subrole axioms. In the latter case, we simply ob-
tain τ (C, b) by combining the explanation of ∀S1 .C(a1 ) with that of (a1 , b) : S1 .
To clarify how the rules → ∀ and → ∀+ work we now give two examples.

Example 3. Let us consider the query Q = ann : P erson for the following
knowledge base:
kevin : ∀kin.P erson (kevin, lara) : relative (lara, eva) : ancestor
(eva, ann) : ancestor T rans(ancestor) T rans(relative)
relative ⊑ kin ancestor ⊑ relative
TRILL first applies the → ∀+ rule to kevin, adding ∀relative.P erson to the
label of lara. The tracing function τ is (in predicate logic):
τ (∀relative.P erson, lara) = { ∀y.kin(kevin, y) → P erson(y),
relative(kevin, lara), relative(kevin, lara) → kin(kevin, lara),
∀z.relative(kevin, lara) ∧ relative(lara, z) → relative(kevin, z)}
Note that the transitivity axiom is not fully instantiated, the variable z is still
present. Then TRILL applies the → ∀+ rule to lara adding ∀ancestor.P erson
to eva. The tracing function τ is (in predicate logic):
40 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

Deterministic rules:
→ unfold: if A ∈ L(a), A atomic and (A ⊑ D) ∈ K, then
if D ∈ / L(a), then
L(a) := L(a) ∪ {D}
τ (D, a) := τ (A, a) ∪ {(A ⊑ D, a)}
→ CE: if (C ⊑ D) ∈ K, then
if (¬C ⊔ D) ∈ / L(a), then
L(a) := L(a) ∪ {¬C ⊔ D}
τ (¬C ⊔ D, a) := {(C ⊑ D, a)}
→ ⊓: if (C1 ⊓ C2 ) ∈ L(a), then
if {C1 , C2 } 6⊆ L(a), then
L(a) := L(a) ∪ {C1 , C2 }
τ (Ci , a) := τ ((C1 ⊓ C2 ), a)
→ ∃: if ∃S.C ∈ L(a), then
if a has no S-neighbor b with C ∈ L(b), then
create new node b, L(b) := {C}, L(ha, bi) := {S},
τ (C, b) := τ ((∃S.C), a), τ (S, ha, bi) := τ ((∃S.C), a)
→ ∀: if ∀S1 .C ∈ L(a1 ), a1 is not indirectly blocked and there is an S1 -neighbor b of a1 , then
if C ∈ / L(b), then L(b) := L(a) ∪ {C}
if thereSis a chain of individuals a2 , . . . , an and roles S2 , . . . , Sn such that
n
{(Trans(Si−1 ), ai , ai−1 ), (Si−1 ⊑ Si , ai , ai−1 )} ⊆ τ (∀S1 .C, a1 )
i=2
and ¬∃an+1 : {(Trans(S Snn ), an+1 , an ), (Sn ⊑ Sn+1 , an+1 )} ⊆ τ (∀S1 .C, a1 ), then
S
τ (C, b) := τ (∀S1 .C, a1 ) \
n i=2
{(Trans(Si−1 ), ai , ai−1 ), (Si−1 ⊑ Si , ai , ai−1 )}∪
{(Trans(Si−1 ), ai , ai−1 , b), (Si−1 ⊑ Si , ai , b)} ∪ τ (S1 , ha1 , bi)
i=2
else
τ (C, b) := τ (∀S1 .C, a1 ) ∪ τ (S1 , ha1 , bi)
→ ∀+ : if ∀(S.C) ∈ L(a), a is not indirectly blocked
and there is an R-neighbor b of a, T rans(R) and R ⊑ S, then
if ∀R.C ∈ / L(b), then L(b) := L(b) ∪ {∀R.C}
τ (∀R.C, b) := τ (∀S.C, a) ∪ τ (R, ha, bi) ∪ {(Trans(R), a, b), (R ⊑ S, a, b)}
→≥: if (≥ nS) ∈ L(a), a is not blocked, then
if there are no n safe S-neighbors b1 , ..., bn of a with bi 6= bj , then
create n new nodes b1 , ..., bn ; L(ha, bi i) := {S};
add in the ABox 6= (bi , bj )
τ (S, ha, bi i) := τ ((≥ nS), a)
τ (6= (bi , bj )) := τ ((≥ nS), a)
→ O: if, {o} ∈ L(a) ∩ L(b) and not a 6= b, then
M erge(a, b)
τ (M erge(a, b)) := τ ({o}, a) ∪ τ ({o}, b)
For each concept Ci in L(a), τ (Ci , b) := τ (Ci , a) ∪ τ (M erge(a, b))
(similarly for roles merged, and correspondingly for concepts in L(b))

Non-deterministic rules:
→ ⊔: if (C1 ⊔ C2 ) ∈ L(a) and a is not indirectly blocked, then
if {C1 , C2 } ∩ L(a) = ∅, then
Generate graphs Gi := G for each i ∈ {1, 2}, L(a) := L(a) ∪ {Ci } for each i ∈ {1, 2}
τ (Ci , a) := τ ((C1 ⊔ C2 ), a)
→≤: if (≤ nS) ∈ L(a), a is not indirectly blocked
and there are m S-neighbors b1 , ..., bm of a with m > n, then
For each possible pair bi , bj , 1 ≤ i, j ≤ m; i 6= j then
Generate a graph Gk := G
τ (M erge(bi , bj )) := (τ ((≤ nS), a) ∪ τ (S, ha, b1 i)... ∪ τ (S, ha, bm i))
For each concept Ci in L(bi ), τ (Ci , bj ) := τ (Ci , bi ) ∪ τ (M erge(bi , bj ))
(similarly for roles merged, and correspondingly for concepts in L(bj ))

Fig. 1. TRILL tableau expansion rules for OWL DL.

A Description Logics Tableau Reasoner in Prolog 41

τ (∀ancestor.P erson, eva) = { ∀y.kin(kevin, y) → P erson(y),

relative(kevin, lara), ancestor(lara, eva),
∀z.relative(kevin, lara) ∧ relative(lara, z) → relative(kevin, z),
∀z.ancestor(lara, eva) ∧ ancestor(eva, z) → ancestor(lara, z),
relative(kevin, lara) → kin(kevin, lara),
ancestor(lara, eva) → relative(lara, eva) }
Now TRILL applies the → ∀ rule to eva adding P erson to the label of ann. The
tracing function τ is (in predicate logic):
τ (P erson, ann) = { ∀y.kin(kevin, y) → P erson(y),
relative(kevin, lara), ancestor(lara, eva), ancestor(eva, ann),
relative(kevin, lara) ∧ relative(lara, ann) → relative(kevin, ann),
ancestor(lara, eva) ∧ ancestor(eva, ann) → ancestor(lara, ann),
relative(kevin, ann) → kin(kevin, ann),
ancestor(lara, ann) → relative(lara, ann) }
Here the chain of transitivity and subrole axioms becomes ground. At this point
the tableau contains a clash so the algorithm stops and returns the explanation
given by τ (P erson, ann).
It is easy to see that the explanation entails the axiom represented by the argu-
ments of τ . In general, the following theorem holds.
Theorem 1. Let Q be an axiom entailed by K and let S be the output of a
reasoner with the tableau expansion rules of Figure 1, such as TRILL, with input
Q and K. Then S ∈ All-InstMinAs(Q, K).
Proof. The full details of the proof are given in [18], Theorem 5, with reference to
the reasoner BUNDLE that implements the same tableau algorithm as TRILL.
The proof proceeds by induction on the number of rule applications following
the proof of Theorem 2 of [11].

6 TRILL
We use the Thea2 library [27] that converts OWL DL ontologies to Prolog by ex-
ploiting a direct translation of the OWL axioms into Prolog facts. For example,
a simple subclass axiom between two named classes Cat ⊑ P et is written using
the subClassOf/2 predicate as subClassOf(‘Cat’,‘Pet’). For more complex
axioms Thea2 exploits the list construct of Prolog, so the axiom N atureLover ≡
P etOwner ⊔ GardenOwner becomes equivalentClasses([‘NatureLover’,
unionOf([‘PetOwner’, ‘GardenOwner’]).
In order to represent the tableau, we use a couple T ableau = (A, T ), where
A is a list containing all the class assertions of the individuals with the corre-
sponding value of τ and the information about nominal individuals, while T is
a triple (G,RBN ,RBR) in which G is a directed graph that contains the struc-
ture of the tableau, RBN is a red-black tree in which each key is a couple of
individuals and the value associated to it is the set of the labels of the edge
between the two individuals, and RBR is a red-black tree in which each key is
a role and the value associated to it is the set of couples of individuals that are
linked by the role. This representation allows us to rapidly find the information
42 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

needed during the execution of the tableau algorithm. For managing the block-
ing system we use a predicate for each blocking state, so we have the following
predicates: nominal/2, blockable/2, blocked/2, indirectly blocked/2 and
safe/3. Each predicate takes as arguments the individual Ind and the tableau,
(A, T ). safe/3 takes as input also the role R. For each nominal individual Ind
at the time of the creation of the ABox we add the atom nominal(Ind) to A,
then every time we have to check the blocking status of an individual we call
the corresponding predicate that returns the status by checking the tableau.
In TRILL deterministic and non-deterministic tableau expansion rules are
treated differently, see Figure 1 for the list of rules. Deterministic rules are im-
plemented by a predicate rule name(T ab, T ab1) that, given the current tableau
T ab, returns the tableau T ab1 to which the rule was applied. Figure 2 shows the
code of the deterministic rule → unfold. The predicate unfold rule/2 searches
in T ab for an individual to which the rule can be applied and calls the predi-
cate find sub sup class/3 in order to find the class to be added to the label
of the individual. find/2 implements the search for a class assertion. Since the
data structure that stores class assertions is currently a list, find/2 simply calls
member/2. absent/3 checks if the class assertion axiom with the associated ex-
planation is already present in A. Non-deterministic rules are implemented by a

unfold_rule((A,T),([(classAssertion(D,Ind),[(Ax,Ind)|Expl])|A],T)):-
find((classAssertion(C,Ind),Expl),A),
atomic(C),
find_sub_sup_class(C,D,Ax),
absent(classAssertion(D,Ind),[(Ax,Ind)|Expl],(A,T)).

find_sub_sup_class(C,D,subClassOf(C,D)):-
subClassOf(C,D).

find_sub_sup_class(C,D,equivalentClasses(L)):-
equivalentClasses(L),
member(C,L),
member(D,L),
C\==D.

Fig. 2. Code of → unfold rules.

predicate rule name(T ab, T abList) that, given the current tableau T ab, returns
the list of tableaux T abList obtained by applying the rule. Figure 3 shows the
code of the non-deterministic rule → ⊔. The predicate or rule/2 searches in
T ab for an individual to which the rule can be applied and unifies T abList with
the list of new tableaux created by scan or list/6.
Expansion rules are applied in order by apply all rules/2, first the non-
deterministic ones and then the deterministic ones. The predicate
apply nondet rules(RuleList,Tab,Tab1) takes as input the list of
A Description Logics Tableau Reasoner in Prolog 43

or_rule((A,T),L):-
find((classAssertion(unionOf(LC),Ind),Expl),A),
\+ indirectly_blocked(Ind,T0),
findall((A1,T),scan_or_list(LC,Ind,Expl,A,T,A1),L),
L\=[],!.

scan_or_list([],_Ind,_Expl,A,T,A).

scan_or_list([C|_T],Ind,Expl,A,T,[(classAssertion(C,Ind),Expl)|A]):-
absent(classAssertion(C,Ind),Expl,(A,T)).

scan_or_list([_C|T],Ind,Expl,A0,T,A):-
scan_or_list(T,Ind,Expl,A0,T,A).

Fig. 3. Code of → ⊔ rule.

non-deterministic rules and the current tableau and returns a tableau obtained
by the application of one rule. apply nondet rules/3 is called as
apply nondet rules([or rule,max rule],Tab,Tab1) and is shown in Fig. 4.
If a non-deterministic rule is applicable, the list of tableaux obtained by its

apply_all_rules(Tab,Tab2):-
apply_nondet_rules([or_rule,max_rule],Tab,Tab1),
(Tab=Tab1 -> Tab2=Tab1 ; apply_all_rules(Tab1,Tab2)).

apply_nondet_rules([],Tab,Tab1):-
apply_det_rules([o_rule,and_rule,unfold_rule,add_exists_rule,
forall_rule,forall_plus_rule,exists_rule,min_rule],Tab,Tab1).

apply_nondet_rules([H|T],Tab,Tab1):-
C=..[H,Tab,L],
call(C),!,
member(Tab1,L),
Tab \= Tab1.

apply_nondet_rules([_|T],Tab,Tab1):-
apply_nondet_rules(T,Tab,Tab1).

Fig. 4. Code of the predicates apply all rules/2 and apply nondet rules/3.

application is returned by the rule predicate, a cut is performed to avoid back-

tracking to other rule choices and a tableau from the list is non-deterministically
chosen with the member/2 predicate. If no non-deterministic rule is applicable,
deterministic rules are tried sequentially with the predicate apply det rules/3,
44 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

shown in Figure 5, that is called as apply det rules(RuleList, Tab,Tab1). It

takes as input the list of deterministic rules and the current tableau and returns
a tableau obtained by the application of one rule. After the application of a
deterministic rule, a cut avoids backtracking to other possible choices for the
deterministic rules. If no rule is applicable, the input tableau is returned and
rule application stops, otherwise a new round of rule application is performed.
In each rule application round, a rule is applied if its result is not already present

apply_det_rules([],Tab,Tab).

apply_det_rules([H|T],Tab,Tab1):-
C=..[H,Tab,Tab1],
call(C),!.

apply_det_rules([_|T],Tab,Tab1):-
apply_det_rules(T,Tab,Tab1).

Fig. 5. Code of the predicates apply det rules/3.

in the tableau. This avoids both infinite loops in rule application and considering
alternative rules when a rule is applicable. In fact, if a rule is applicable in a
tableau, it will also be so in any tableaux obtained by its expansion, thus the
choice of which expansion rule to apply introduces “don’t care” non-determinism.
Differently, non-deterministic rules introduce in the algorithm also “don’t know”
non-determinism, since a single tableau is expanded into a set of tableaux. We
use Prolog search only to handle “don’t know” non-determinism.

Example 4. Let us consider the knowledge base presented in Example 1 and the
query Q = kevin : N atureLover. After the initialization of the tableau, TRILL
can apply the → unfold rule to the individuals tom or fluffy. Suppose it selects
tom. The tracing function τ becomes (in predicate logic):
τ (P et, tom) = { Cat(tom), Cat(tom) → P et(tom)}
At this point TRILL applies the → CE rule to kevin, adding
¬(∃hasAnimal.P et) ⊔ N atureLover = ∀hasAnimal.(¬P et) ⊔ N atureLover to
L(kevin) with the following tracing function:
τ (∀hasAnimal.(¬P et) ⊔ N atureLover, kevin) = {
∃y.hasAnimal(kevin, y) ∧ P et(y) → N atureLover(kevin)}
Then it applies the → ⊔ rule to kevin generating two tableaux. In this step we
have a backtracking point because we have to choose which tableau to expand.
In the first one TRILL adds ∀hasAnimal.(¬P et) to the label of kevin with the
tracing function
τ (∀hasAnimal.(¬P et), kevin) = {
∃y.hasAnimal(kevin, y) ∧ P et(y) → N atureLover(kevin)}
Now it can apply the → ∀ rule to kevin. In this step it can use either tom or
fluffy, supposing it selects tom the tracing function will be:
A Description Logics Tableau Reasoner in Prolog 45

τ (¬(P et), tom) = { hasAnimal(kevin, tom),

hasAnimal(kevin, tom) ∧ P et(tom) → N atureLover(kevin)}
At this point this first tableau contains a clash for the individual tom, thus
TRILL backtracks and expands the second tableau. The second tableau was
created by applying the → CE rule that added N atureLover to the label of
kevin, so the second tableau contains a clash, too. Now TRILL joins the tracing
functions of the two clashes to find the following InstMinA:
{hasAnimal(kevin, tom) ∧ P et(tom) → N atureLover(kevin),
hasAnimal(kevin, tom), Cat(tom), Cat(tom) → P et(tom)}.

The tableau algorithm returns a single InstMinA. The computation of All-

InstMinAs(Q, K) is performed by simply calling findall/3 over the tableau
predicate.
Example 5. Let us consider Example 4. Once the first InstMinA is found, TRILL
performs backtracking. Supposing it applies the → unfold rule to the individual
fluffy instead of tom and following the same steps used in Example 4 it finds a
new InstMinA:
{hasAnimal(kevin, fluffy) ∧ P et(fluffy) → N atureLover(kevin),
hasAnimal(kevin, fluffy), Cat(fluffy), Cat(fluffy) → P et(fluffy)}.

7 Experiments
In this section, we evaluate TRILL performances when computing instantiated
explanations by comparing it to BUNDLE that also solves the inst-min-a-enum
problem. We consider four different knowledge bases of various complexity: the
BRCA3 that models the risk factor of breast cancer, an extract of the DBPedia4
ontology that has been obtained from Wikipedia, the Biopax level 35 that models
metabolic pathways and the Vicodi6 that contains information on European
history. For the tests, we used the DBPedia and the Biopax KBs without ABox
while for BRCA and Vicodi we used a little ABox contaning 1 individual for the
first one and 19 individuals for the second one. We ran two different subclass-of
queries w.r.t. the DBPedia and the Biopax datasets and two different instance-of
queries w.r.t. the other KBs. For each KB, we ran each query 50 times for a total
of 100 executions of the reasoners. Table 2 shows, for each ontology, the number of
axioms, the average number of explanations and the average time in milliseconds
that TRILL and BUNDLE took for answering the queries. In particular, in
order to stress the algorithm, the BRCA and the version of DBPedia that we
used contain a large number of subclass axioms between complex concepts.These
preliminary tests show that TRILL performance can sometimes be better than
BUNDLE, even if it lacks all the optimizations that BUNDLE inherits from
Pellet. This represents evidence that a Prolog implementation of a Semantic
Web tableau reasoner is feasible and that may lead to a practical system.
3
http://www2.cs.man.ac.uk/~klinovp/pronto/brc/cancer_cc.owl
4
http://dbpedia.org/
5
http://www.biopax.org/
6
http://www.vicodi.org/
46 Riccardo Zese, Elena Bellodi, Evelina Lamma and Fabrizio Riguzzi

TRILL BUNDLE
Dataset n. axioms av. n. expl time (ms) time (ms)
BRCA 322 6.5 95,691 10,210
DBPedia 535 16.0 80,804 28,040
Biopax level 3 826 2.0 24 1,451
Vicodi 220 1.0 136 1,004
Table 2. Results of the experiments in terms of average times for inference.

8 Conclusions
In this paper we presented the algorithm TRILL for reasoning on SHOIN (D)
knowledge bases and its Prolog implementation. The results we obtained show
that Prolog is a viable language for implementing DL reasoning algorithms and
that performances are comparable with those of a state of the art reasoner.
In the future we plan to apply various optimizations to TRILL in order to
better manage the expansion of the tableau. In particular, we plan to carefully
choose the rule and node application order. Moreover, we plan to exploit TRILL
for performing reasoning on probabilistic ontologies and on integration of prob-
abilistic logic programming with DLs and for implementing learning algorithms
for such integration, along the lines of [4, 5, 22].

References
1. Baader, F., Calvanese, D., McGuinness, D.L., Nardi, D., Patel-Schneider, P.F.
(eds.): The Description Logic Handbook: Theory, Implementation, and Applica-
tions. Cambridge University Press (2003)
2. Baader, F., Horrocks, I., Sattler, U.: Description logics. In: Handbook of knowledge
representation, chap. 3, pp. 135–179. Elsevier (2008)
3. Beckert, B., Posegga, J.: leantap: Lean tableau-based deduction. J. Autom. Rea-
soning 15(3), 339–358 (1995)
4. Bellodi, E., Riguzzi, F.: Learning the structure of probabilistic logic programs. In:
Muggleton, S.H., Tamaddoni-Nezhad, A., Lisi, F.A. (eds.) ILP 2011. LNCS, vol.
7207, pp. 61–75. Springer (2012)
5. Bellodi, E., Riguzzi, F.: Expectation Maximization over binary decision diagrams
for probabilistic logic programs. Intel. Data Anal. 17(2), 343–363 (2013)
6. Faizi, I.: A Description Logic Prover in Prolog, Bachelor’s thesis, Informatics Math-
ematical Modelling, Technical University of Denmark (2011)
7. Halaschek-Wiener, C., Kalyanpur, A., Parsia, B.: Extending tableau tracing for
ABox updates. Tech. rep., University of Maryland (2006)
8. Herchenröder, T.: Lightweight Semantic Web Oriented Reasoning in Prolog:
Tableaux Inference for Description Logics. Master’s thesis, School of Informatics,
University of Edinburgh (2006)
9. Hitzler, P., Krötzsch, M., Rudolph, S.: Foundations of Semantic Web Technologies.
CRCPress (2009)
10. Hustadt, U., Motik, B., Sattler, U.: Deciding expressive description logics in the
framework of resolution. Inf. Comput. 206(5), 579–601 (2008)
A Description Logics Tableau Reasoner in Prolog 47

11. Kalyanpur, A.: Debugging and Repair of OWL Ontologies. Ph.D. thesis, The Grad-
uate School of the University of Maryland (2006)
12. Kalyanpur, A., Parsia, B., Horridge, M., Sirin, E.: Finding all justifications of OWL
DL entailments. In: Aberer, K., et al. (eds.) ISWC/ASWC 2007. LNCS, vol. 4825,
pp. 267–280. Springer (2007)
13. Kalyanpur, A., Parsia, B., Sirin, E., Hendler, J.A.: Debugging unsatisfiable classes
in OWL ontologies. J. Web Sem. 3(4), 268–293 (2005)
14. Lukácsy, G., Szeredi, P.: Efficient description logic reasoning in prolog: The dlog
system. TPLP 9(3), 343–414 (2009)
15. Meissner, A.: An automated deduction system for description logic with alcn lan-
guage. Studia z Automatyki i Informatyki 28-29, 91–110 (2004)
16. Patel-Schneider, P, F., Horrocks, I., Bechhofer, S.: Tutorial on OWL (2003)
17. Reiter, R.: A theory of diagnosis from first principles. Artif. Intell. 32(1), 57–95
(1987)
18. Riguzzi, F., Bellodi, E., Lamma, E., , Zese, R.: Probabilistic description logics
under the distribution semantics. Tech. Rep. ML-01, University of Ferrara (2013),
http://sites.unife.it/ml/bundle
19. Riguzzi, F., Bellodi, E., Lamma, E.: Probabilistic Datalog+/- under the distribu-
tion semantics. In: Kazakov, Y., Lembo, D., Wolter, F. (eds.) DL 2012. CEUR
Workshop Proceedings, vol. 846. Sun SITE Central Europe (2012)
20. Riguzzi, F., Bellodi, E., Lamma, E., Zese, R.: Epistemic and statistical probabilistic
ontologies. In: Bobillo, F., et al. (eds.) URSW 2012. CEUR Workshop Proceedings,
vol. 900, pp. 3–14. Sun SITE Central Europe (2012)
21. Riguzzi, F., Bellodi, E., Lamma, E., Zese, R.: BUNDLE: A reasoner for proba-
bilistic ontologies. In: Faber, W., Lembo, D. (eds.) RR 2013. LNCS, vol. 7994, pp.
183–197. Springer (2013), http://www.ing.unife.it/docenti/FabrizioRiguzzi/
Papers/RigBelLam-RR13b.pdf
22. Riguzzi, F., Bellodi, E., Lamma, E., Zese, R.: Parameter learning for probabilistic
ontologies. In: Faber, W., Lembo, D. (eds.) RR 2013. LNCS, vol. 7994, pp. 265–270.
Springer (2013), http://www.ing.unife.it/docenti/FabrizioRiguzzi/Papers/
RigBelLam-RR13a.pdf
23. Sato, T.: A statistical learning method for logic programs with distribution seman-
tics. In: ICLP 1995. pp. 715–729. MIT Press (1995)
24. Sattler, U., Calvanese, D., Molitor, R.: Relationships with other formalisms. In:
Description Logic Handbook, chap. 4, pp. 137–177. Cambridge University Press
(2003)
25. Schlobach, S., Cornet, R.: Non-standard reasoning services for the debugging of
description logic terminologies. In: Gottlob, G., Walsh, T. (eds.) IJCAI 2003. pp.
355–362. Morgan Kaufmann (2003)
26. Sirin, E., Parsia, B., Cuenca-Grau, B., Kalyanpur, A., Katz, Y.: Pellet: A practical
OWL-DL reasoner. J. Web Sem. 5(2), 51–53 (2007)
27. Vassiliadis, V., Wielemaker, J., Mungall, C.: Processing owl2 ontologies using thea:
An application of logic programming. In: International Workshop on OWL: Ex-
periences and Directions. CEUR Workshop Proceedings, vol. 529. CEUR-WS.org
(2009)
28. Wielemaker, J., Schrijvers, T., Triska, M., Lager, T.: SWI-Prolog. Theory and
Practice of Logic Programming 12(1-2), 67–96 (2012)