Benjamin N. Grosof
MIT Sloan School of Management
Description Logic Programs: Combining Logic Programs with Description LogicCambridge,
MA, USA
bgrosof@mit.edu
Ian Horrocks
University of Manchester
Manchester, United Kingdom
horrocks@cs.man.ac.uk
Raphael Volz
University of Karlsruhe
Karlsruhe, Germany
volz@fzi.de
Stefan Decker
USC ISI
Los Angeles, CA, USA
stefan@isi.edu
Copyright is held by the
author/owner(s).
WWW2003, May 2024, 2003, Budapest, Hungary.
ACM 1581136803/03/0005.
Abstract:
We show how to perform DLPfusion: the bidirectional translation of premises and inferences (including typical kinds of queries) from the DLP fragment of DL to LP, and vice versa from the DLP fragment of LP to DL. In particular, this translation enables one to ``build rules on top of ontologies'': it enables the rule KR to have access to DL ontological definitions for vocabulary primitives (e.g., predicates and individual constants) used by the rules. Conversely, the DLPfusion technique likewise enables one to ``build ontologies on top of rules'': it enables ontological definitions to be supplemented by rules, or imported into DL from rules. It also enables available efficient LP inferencing algorithms/implementations to be exploited for reasoning over largescale DL ontologies.
Categories and Subject Descriptors
I.2.4 [Knowledge Representation Formalisms and Methods]: Representation languages; H.3.4 [World Wide Web]; H.4.m [Information Systems Applications]: Miscellaneous.General Terms
Languages, Standardization, TheoryKeywords
Semantic Web, rules, ontologies, logic programs, Description Logic, knowledge representation, XML, RDF, modeltheoretic semantics, inferencing, interoperability, translation, information integration
1 Introduction
The challenge we address in this paper is how and why to combine rules with ontologies for the Semantic Web (SW). In this paper, we focus on meeting key requirements for such a combination of rules and ontologies by establishing the basis for a combined logical knowledge representation (KR) formalism. We start from the current draft standards for ontologies (DAML+OIL) [6] and for rules (RuleML) [3] in the Semantic Web context, and show how aspects of each language can be translated to the other. Both standards correspond with established KR formalisms: Description Logic (DL) in the case of DAML+OIL, and (declarative) logic programs (LP) in the case of RuleML.^{1} This correspondence allows us to exploit results w.r.t. the mapping of each KR to classical First Order Logic (FOL).
A mapping between ontology and rule languages is important for many aspects of the Semantic Web:
Language layering The Semantic Web can be viewed as largely about ``KR meets the Web''. Over the last two years or so, a broad consensus has evolved in the Semantic Web community that the vision of the Semantic Web includes, specifically, rules as well as ontologies. A key requirement for the Semantic Web's architecture overall, then, is to be able to layer rules on top of ontologiesin particular to create and reason with rulebases that mention vocabulary specified by ontologybased knowledge basesand to do so in a semantically coherent and powerful manner.
Querying The capabilities of ontology languages with respect to instances can be rather low, and even conjunctive queriesthe least expressive query language usually considered in database researchare often not supported [4]. This area is a stronghold of rules, which offer extensive facilities for instance reasoning. Hence, it is interesting to consider combining DLs with the rule paradigm in order to state expressive instance queries w.r.t. terminological knowledge bases.
Data integration The majority of today's data resides in relational databases. As the Semantic Web grows in importance, people will probably start exporting their data according to some chosen ontology. This essentially leads to data that is replicated in order to enable ontologybased processing, e.g., by reading the exported files into a classifier such as FaCT [12] or RACER [10]. Logic programming systems such as XSB [16], however, can access databases directly through builtin predicates. Furthermore, restricted variants of logic programs, such as the ones established in this paper, can be directly implemented on top of SQL99compliant relational databases. Hence, an LPbased implementation of an ontology language allows a closer interaction with live data.
Semantic Web Services A taskoriented motivation for combining rules with ontologies arises from the efforts to design and build Semantic Web Services (SWS). Semantic Web Services attempt to describe services in a knowledgebased manner in order to use them for a variety of purposes, including: discovery and search; selection, evaluation, negotiation, and contracting; composition and planning; execution; and monitoring. Both rules and ontologies are necessary for such service descriptions and play complementary roles: while ontologies are useful for representing hierarchical categorisation of services overall and of their inputs and outputs, rules are useful for representing contingent features such as business policies, or the relationship between preconditions and postconditions.
2 Overview of the Approach
This section gives an overview of our approach and sketches the
outline of the remainder of the paper. Our approach is driven by
the insight that understanding the expressive intersection
of two the KRs will be crucial to understanding the expressive
combination/union of the two KRs. Hence, we start with the
goal of understanding the relationship between both logic based KR
formalisms (so as to be able to combine knowledge taken from both):
Description Logics (decidable fragments of FOL closely related to
propositional modal and dynamic logics
[17]), and Logic Programs
(see, e.g., [2]
for review) which in turn is closely related to the Horn fragment
of FOL. Since Description Logics resemble a subset of FOL without
function symbols, we similarly focus on the fragment of Horn FOL,
defHorn, that contains no function symbols. Both DL and LP
are then related to defHorn.
The established correspondence is used to define a new intermediate KR called Description Horn Logic (DHL), which is contained within the intersection, and the closely related Description Logic Programs (DLP), which can be viewed as DHL with a moderate weakening as to the kinds of conclusion can be drawn.
Figure 1 illustrates the relationship between the various KRs and their expressive classes. DL and Horn are strict (decidable) subsets of FOL. LP, on the other hand, intersects with FOL but neither includes nor is fully included by FOL. For example, FOL can express (positive) disjunctions, which are inexpressible in LP. On the other hand, several expressive features of LP, which are frequently used in practical rulebased applications, are inexpressible in FOL (and consequently also outside of defHorn). One example is negationasfailure, a basic kind of logical nonmonotonicity. Another example is procedural attachments, e.g., the association of actionperforming procedural invocations with the drawing of conclusions about particular predicates.
Description Logic Programs, our newly defined intermediate KR, is contained within the intersection of DL and LP. ``Full'' LP, including nonmonotonicity and procedural attachments, can thus be viewed as including an ``ontology sublanguage'', namely the DLP subset of DL.
Rather than working from the intersection as we do in this paper, one may instead directly address the expressive union of DL and LP by studying the expressive union of DL and LP within the overall framework of FOL. This is certainly an interesting thing to do. However, to our knowledge, this has not yet been well characterised theoretically, e.g., it is unclear how, if at all, such a union differs from full FOL.
Full FOL has some significant practical and expressive drawbacks as a KR in which to combine DL and rules. First, full FOL has severe computational complexity: it is undecidable in the general case, and intractable even under the Datalog restriction (see Section 3.2). Second, it is not understood even at a basic research level how to expressively extend full FOL to provide nonmonotonicity and procedural attachments; yet these are crucial expressive features in many (perhaps most) practical usages of rules. Third, full FOL and its inferencing techniques have severe practicable limitations since it is unfamiliar to the great majority of mainstream software engineers, whereas rules (e.g., in the form of SQLtype queries, or Prolog) are familiar conceptually to many of them.
Via the DLP KR, we give a new technique to combine DL and LP. We show how to perform DLPfusion: the bidirectional mapping of premises and inferences (including typical kinds of queries) from the DLP fragment of DL to LP, and from the DLP fragment of LP to DL. DLPfusion allows us to fuse the two logical KRs so that information from each can be used in the other. The DLPfusion technique promises several benefits. In particular, DLPfusion enables one to ``build rules on top of ontologies'': it enables the rule KR to have access to DL ontological definitions for vocabulary primitives (e.g., predicates and individual constants) used by the rules. Conversely, the technique enables one to ``build ontologies on top of rules'': it enables ontological definitions to be supplemented by rules, or imported into DL from rules. It also enables efficient LP inferencing algorithms/implementations, e.g., rule or relational database engines, to be exploited for reasoning over largescale DL ontologies.
3 Preliminaries
In this section we will introduce Horn Logic, Description Logic (DL) and the DL based ontology language DAML+OIL. In particular, we will describe their syntax and formalise their meaning in terms of classical First Order Logic (FOL).
3.1 DAML+OIL and Description Logic
DAML+OIL is an ontology language designed for use on the (semantic) web. Although DAML+OIL is syntactically ``layered'' on top of RDFS, semantically it is layered on a subset of RDFS. This subset does not include RDFS's recursive meta model (i.e., the unrestricted use of the type relation), but instead treats RDFS as a very simple DL supporting only atomic class names. Like other DLs, this ``DAML+OIL subset'' of RDFS corresponds to a fragment of classical FOL, making it much easier to develop mappings to rule languages as well as to DLs. From now on, when we talk about RDFS, we will be referring to the DAML+OIL subset of RDFS.
DAML+OIL is equivalent to a very expressive DLin fact it is equivalent to the DL [13, 11]. In addition to ``abstract'' classes and individuals, DAML+OIL also supports the use of ``concrete'' datatypes and data values (the in ). In this paper, however, we will restrict our attention to the abstract part of the language, which corresponds to the DL.
Figure 2 shows how DAML+OIL statements correspond to axioms, where (possibly subscripted) is a class, (possibly subscripted) is a property, is the inverse of , is the transitive closure of , (possibly subscripted) is an individual and is an abbreviation for for some class (i.e., the most general class, called ``Thing'' in DAML+OIL).
It can be seen that all DAML+OIL statements can be reduced to class/property inclusion axioms and ground facts (asserted classinstance and instancepropertyinstance relationships).^{2} In the case of transitiveProperty, however, the axiom is taken to be equivalent to asserting that is a transitive property (like DAML+OIL, does not include the transitive closure operator).
As in any DL, DAML+OIL classes can be names (URIs) or expressions, and a variety of constructors are provided for building class expressions. Figure 3 summarises the available constructors and their correspondence with class expressions.
The meaning of is usually given by a model theory [13]. However, can also be seen in terms of a correspondence to FOL, where classes correspond to unary predicates, properties correspond to binary predicates and subclass/property axioms correspond to implication [7, 4].
To be more precise, individuals are equivalent to FOL constants, classes and class expressions are equivalent to FOL formulae with one free variable, and properties (and property expressions when supported by the DL) are equivalent to FOL formulae with two free variables. Class and property inclusion axioms are equivalent to FOL sentences consisting of an implication between two formulae with the free variables universally quantified at the outer level. E.g., a DL axiom of the form is equivalent to a FOL sentence of the form . DL axioms of the form and correspond to ground atoms and . Finally, DL axioms asserting the transitivity of a property , the functionality of a property and that property is the inverse of property are equivalent to FOL sentences of the form , and respectively.
Figure 4 summarises the above equivalences and shows the FOL formulae corresponding to the DL class expressions described in Figure 3, where are constants, and is the free variable. These formulae can be composed in the obvious way, e.g., .
As a notational convention we will, throughout the paper, use and for constants and , , and for variables.
3.2 Logic Programs and Horn FOL
Declarative logic programs (LP) is the KR whose semantics underlies in a large part the four families of rule systems that are currently most commercially importantSQL relational databases, OPS5heritage production rules, Prolog, and EventConditionAction rulesas well as the proposals for rules in context of the Semantic Web.
As mentioned before, the commonly used expressiveness of full LP includes features, notably negationasfailure/priorities and procedural attachments, that are not expressible in FOL, much less in DL. We thus concentrate on only an expressive portion of LP.
An ordinary (a.k.a. ``normal''^{3}) LP is a set of
rules each having the form:
where , are
atoms (atomic formulae), and
. Note that no
restriction is placed on the arity of the predicates appearing in
these atoms. Logical variables, and logical functions (with any
arity), may appear unrestrictedly in these atoms.
is called the head (a.k.a.
consequent) of the rule;
is called the body (a.k.a. antecedent) of the
rule.
is to be read as ``if'', so that the overall rule should be read
as ``[head] if [body]'', i.e., ``if [body] then [head]''. If
, then the body is empty, i.e.,
, and notationally the ``
'' is often omitted. A fact is a rule whose body is empty
and whose head is a ground atom.
stands for negationasfailure, a logically nonmonotonic form of
negation whose semantics differs, in general, significantly from
the semantics of classical negation (). Intuitively,
means
`` is not believed'' (i.e., is
unknown or false), whereas
means `` is false''. Intuitively, each rule
can be viewed as universally quantified at the outer level. More
precisely, each rule can be viewed as standing for the set of all
its ground instantiations.
A definite LP is an ordinary LP in which
negationasfailure does not appear, i.e., a set of rules each
having the form:
where , are
atoms, and .
Definite LP is closely related syntactically and semantically to
the Horn fragment of FOL, a.k.a. Hornclause logic. A clause in FOL
has the form:
where each is a (classical) literal. A
literal has either the form (1)
or (2)
, where
is an atom. The literal is said to be positive in case
(1), or to be negative in case (2). A clause is said to be
Horn when at most one of its literals is
positive. A Horn clause is said to be definite when
exactly one of its literals is positive. A definite Horn
clause is also known as a Horn rule. A definite Horn
clause, a.k.a. Horn rule, can thus be written in the
form:
where , are
atoms, and . We say that this Horn rule
corresponds to the definite LP rule that has the same
syntactic form, and vice versa. Likewise, we say that a Horn
ruleset and a definite LP ruleset
correspond to each other when
their rules do (isomorphically). We then also say that
is the
LPcorrespondent of , and
conversely that is the
Horncorrespondent of .
As mentioned above, it is implicit in this notation that all
logical variables are universally quantified at the outer level,
i.e., over the scope of the whole clause. E.g., the rule
can be written equivalently as:
.
Note the similarity with the FOL equivalent of a DL inclusion
(subClassOf) axiom given in
Figure 4.
An LP rule or Horn clause is said to be equalityfree when the equality predicate does not appear in it. Likewise, each is said to be Datalog when no logical functions (of arity greater than zero) appear in it.^{4}
The semantics of an ordinary LP is defined to be a
conclusion set, where each conclusion is a ground atom,
i.e., fact, entailed by the LP. Formally, the semantics of a
definite LP is defined as follows. Let
stand for the Herbrand base of
. The conclusion set
is the smallest (w.r.t. set
inclusion) subset of such that for any rule
,
if
then
.
The relationship of LP semantics to FOL semantics is relatively simple to describe for the case of definite equalityfree Datalog LP, which we call defLP. The syntactically corresponding fragment of FOL is definite equalityfree Datalog Horn FOL, which we call defHorn. Let be a defLP. Let stand for the corresponding defHorn ruleset. The conclusion set of then coincides with the minimal (w.r.t. set inclusion) Herbrand model of .
Hence, the defLP and the defHorn ruleset entail exactly the
same set of facts. Every conclusion of the defLP is also a
conclusion of the defHorn ruleset. Relative to the defHorn
ruleset, the defLP is thus sound; moreover, it is complete for
factform conclusions, i.e., for queries whose answers amount to
conjunctions of facts. However, the defLP is a mildly
weaker version of the defHorn ruleset, in the following
sense. Every conclusion of the defLP must have the form of a fact.
By contrast, the entailments, i.e., conclusions, of the defHorn
ruleset are not restricted to be facts. E.g., suppose
consists of the two
rules
and
.
Then it entails
(a nonunit derived clause) whereas does
not. In practical applications, however, quite often only the
factform conclusions are desired, e.g., an application might be
interested above only in whether or not
is
entailed. The defLP has the virtue of conceptual and computational
simplicity. Thinking in terms of expressive classes, we will view
defLP as an expressive subset of defHornwe will call
it the expressive fsubset. defLP is a mild weakening of
defHorn along the dimension of entailment power, permitting only
factform conclusionswe will call this fweakening.
In return for this fweakening, defLP has some quite attractive computational characteristics (as well as being expressively extensible in directions that FOL is not, as discussed earlier). For the propositional case of defLP, exhaustive inferencing is where  i.e., worstcase linear time [8]. For the general case with logical variables, the entire conclusion set of a defLP can be computed in time , when there is a constant bound on the number of logical variables per rule (this restriction, which we will call VB, is typically met in practise). Inferencing in defLP is thus tractable (worstcase polynomial time) given VB. In contrast, DLs are generally not tractable (typically ExpTime or even NExpTime complexity for key inference problems), and full FOL is not decidable.
4 Mapping DL to defHorn
In this section we will discuss how DL languages (e.g., DAML+OIL) can be mapped to defHorn, and vice versa.
4.1 Expressive Restrictions
We will first discuss the expressive restrictions of DL and defHorn as these will constrain the subset of DL and defHorn for which a complete mapping can be defined.
DLs are decidable subsets of FOL where the decidability is due in large part to their having (a form of) the tree model property [19].^{5} This property says that a DL class has a model (an interpretation in which is nonempty) iff has a treeshaped model, i.e., one in which the interpretation of properties defines a tree shaped directed graph.
This requirement severely restricts the way variables and
quantifiers can be used. In particular, quantifiers must be
relativised via atomic formulae (as in the guarded fragment
of FOL [9]), i.e., the
quantified variable must occur in a property predicate along with
the free variable (recall that DL classes correspond to formulae
with one free variable). For example, the DL class corresponds to the FOL formula
, where
the property predicate acts as a guard. One obvious
consequence of this restriction is that it is impossible to
describe classes whose instances are related to another anonymous
individual via different property paths. For example, it is
impossible to assert that individuals who live and work at the same
location are ``HomeWorkers''. This is easy with a Horn rule,
e.g.:
Another restriction in DLs is that only unary and binary predicates can usually be captured.^{6} This is a less onerous restriction, however, as techniques for reifying higher arity predicates are well known [12].
Definite Horn FOL requires that all variables are universally
quantified (at the outer level of the rule), and restricts logical
connectives in certain ways. One obvious consequence of the
restriction on quantifiers is that it is impossible to assert the
existence of individuals whose identity might not be known. For
example, it is impossible to assert that all persons have a father
(known or unknown). This is easy with a DL axiom, e.g.:
No negation may appear within the body of a rule, nor within the head. No existentials may appear within the head. Thus it is impossible to assert, e.g., that all persons are either men or women (but not both). This would also be easy using DL axioms, e.g.:
The Datalog restriction of defHorn is not an issue for mapping DL into it, since DL also has the Datalog restriction. Finally, the equalityfree restriction of defHorn is a significant restriction in that it prevents representing (partial)functionality of a property and also prevents representing maximum cardinality. The prohibition against existentials in the head prevents representing minimum cardinality.
4.2 Mapping Statements
In this section, we show how (some of) the statements
(axioms) of DL and DL based languages (such as DAML+OIL and OWL)
correspond to defHorn statements (rules).
4.2.1 RDFS Statements
RDFS provides a subset of the DL statements described in Section 3.1: subclass, subproperty, range, and domain statements (which in a DL setting are often called Tbox axioms); and asserted classinstance (type) and instancepropertyinstance relationships (which in a DL setting are often called Abox axioms).
As we saw in Section 3.1, a DL inclusion axiom corresponds to an FOL implication. This leads to a straightforward mapping from class and property inclusion axioms to defHorn rules as follows:

, i.e., class
is subclass of class ,
maps to:

, i.e.,
is a subproperty of ,
maps to:
As shown in Figure 2, RDFS range and domain statements correspond to DL axioms of the form (range of is ) and (domain of is ). From Figure 4, we can see that these are equivalent to the FOL sentences and , which can be simplified to and respectively. These FOL sentences are already in defHorn form, which gives us the following mappings for range and domain:

, i.e.,
the range of property is class ,
maps to:

, i.e.,
the domain of property is class ,
maps to:
Finally, asserted classinstance (type) and instancepropertyinstance relationships, which correspond to DL axioms of the form and respectively (Abox axioms), are equivalent to FOL sentences of the form and , where and are constants. These are already in defHorn form: they are simply rules with empty bodies (which are normally omitted):
 , i.e., the individual
is an instance of the class
, maps to:

, i.e., the
individual is related to the individual
via the property ,
maps to:
4.2.2 DAML+OIL statements
DAML+OIL extends RDF with additional statements about classes and properties (Tbox axioms). In particular, it adds explicit statements about class, property and individual equality and inequality, as well as statements asserting property inverses, transitivity, functionality (unique) and inverse functionality (unambiguous).
As discussed in Section 3.1, class and property equivalence axioms can be replaced with a symmetrical pair of inclusion axioms, so they can be mapped to a symmetrical pair of defHorn rules as follows:
 , i.e., the class
is equivalent to (has the same
extension as) the class , maps to:
 , i.e., the property
is equivalent to (has the same
extension as) the property , maps
to:
As we saw in Section 3.1, the semantics of inverse axioms of the form are captured by FOL sentences of the form , and the semantics of transitivity axioms of the form are captured by FOL sentences of the form . This leads to a direct mapping into defHorn as follows:
 , i.e., the property
is the inverse of the property
, maps to:

, i.e., the property
is transitive, maps to:
As we saw in Section 3.1, DL axioms asserting the functionality of properties correspond to FOL sentences with equality. E.g., a DL axiom ( is a functional property) corresponds to the FOL sentence .^{7} This kind of axiom cannot be dealt with in our current framework (see Section 4.1) as it would require defHorn rules with equality in the head, i.e., rules of the form .
4.3 Mapping Class Constructors
In the previous section we showed how DL axioms correspond with defHorn rules, and how these can be used to make statements about classes and properties. In DLs, the classes appearing in such axioms need not be atomic, but can be complex compound expressions built up from atomic classes and properties using a variety of constructors. A great deal of the power of DLs derives from this feature, and in particular from the set of constructors provided.^{8} In the following section we will show how these DL expressions correspond to expressions in the body of defHorn rules.
In the following we will, as usual, use to denote classes, to denote properties and to denote an integer.
Conjunction (DL )
A DL class can be formed by conjoining existing classes, e.g.,
. From
Figure 4 it can be
seen that this corresponds to a conjunction of unary predicates.
Conjunction can be directly expressed in the body of a defHorn
rule. E.g., when a conjunction occurs on the l.h.s. of a subclass
axiom, it simply becomes conjunction in the body of the
corresponding rule
Similarly, when a conjunction occurs on the r.h.s. of a subclass
axiom, it becomes conjunction in the head of the corresponding
rule:
This is then easily transformed (via the LloydTopor transformations [14]) into a pair of defHorn rules:
Disjunction (DL )
A DL class can be formed from a disjunction of existing classes,
e.g., . From
Figure 4 it can be
seen that this corresponds to a disjunction of unary predicates.
When a disjunction occurs on the l.h.s. of a subclass axiom it
simply becomes disjunction in the body of the corresponding
rule:
This is easily transformed (again by LloydTopor) into a pair of defHorn rules:
When a disjunction occurs on the r.h.s. of a subclass axiom it becomes a disjunction in the head of the corresponding rule, and this cannot be handled within the defHorn framework.
Universal Restriction (DL )
In a DL, the universal quantifier can only be used in
restrictionsexpressions of the form (see
Section 4.1).
This is equivalent to an FOL clause of the form
(see Figure 4).
must be a single primitive property,
but may be a compound expression.
Therefore, when a universal restriction occurs on the r.h.s. of a
subclass axiom it becomes an implication in the head of the
corresponding rule:
which is easily transformed into the standard defHorn rule:
When a universal restriction occurs on the l.h.s. of a subclass axiom it becomes an implication in the body of the corresponding rule. This cannot, in general, be mapped into defHorn as it would require negation in a rule body.
Existential Restriction (DL )
In a DL, the existential quantifier (like the universal quantifier) can only be used in restrictions of the form . This is equivalent to an FOL clause of the form (see Figure 4). must be a single primitive property, but may be a compound expression.
When an existential restriction occurs on the l.h.s. of a
subclass axiom, it becomes a conjunction in the body of a standard
defHorn rule:
When an existential restriction occurs on the r.h.s. of a subclass axiom, it becomes a conjunction in the head of the corresponding rule, with a variable that is existentially quantified. This cannot be handled within the defHorn framework.
Negation and Cardinality Restrictions (DL , and )
These constructors cannot, in general, be mapped into defHorn. The case of negation is obvious as negation is not allowed in either the head or body of a defHorn rule. As can be seen in Figure 4, cardinality restrictions correspond to assertions of variable equality and inequality in FOL, and this is again outside of the defHorn framework.
In some cases, however, it would be possible to simplify the DL expression using the usual rewriting tautologies of FOL in order to eliminate the offending operator(s). For example, negation can always be pushed inward by using a combination of De Morgan's laws and equivalences such as and [1]. Further simplifications are also possible, e.g., using the equivalences , and . For the sake of simplicity, however, we will assume that DL expressions are in a canonical form where all relevant simplifications have been carried out.
4.4 Defining DHL via a Recursive Mapping from DL to defHorn
As we saw in Section 4.3, some DL constructors (conjunction and universal restriction) can be mapped to the heads of rules whenever they occur on the r.h.s. of an inclusion axiom, while some DL constructors (conjunction, disjunction and existential restriction) can be mapped to the bodies of rules whenever they occur on the l.h.s. of an inclusion axiom. This naturally leads to the definition of two DL languages, classes from which can be mapped into the head or body of LP rules; we will refer to these two languages as and respectively.
The syntax of the two languages is defined as follows. In both languages an atomic name is a class, and if and are classes, then is also a class. In , if is a class and is a property, then is also a class, while in , if are classes and is a property, then and are also classes.
Using the mappings from
Section 4.3, we
can now follow the approach of
[4] and define a recursive
mapping function which takes a DL
axiom of the form
, where
is an class and
is an class, and maps it into
an LP rule of the form
. The mapping is defined as follows:
where is an atomic class name, and are classes, is a property and are variables, with being a ``fresh'' variable, i.e., one that has not previously been used.
As we saw in Section 4.3, rules of the form are rewritten as two rules and ; rules of the form are rewritten as ; and rules of the form are rewritten as two rules and .
For example, would map the DL
axiom
into the LP rule
which is rewritten as the pair of rules
We call the intersection of
and , i.e., the language where an atomic name
is a class, and if
and are classes, then is also a class. We then extend
to deal with axioms of the
form , where
and are both classes:
As we saw in
Section 4.2.1,
range and domain axioms
and
are
mapped into defHorn rules of the form
and
respectively. Moreover, classinstance and
instancepropertyinstance axioms and
are mapped into
defHorn facts (i.e., rules with empty bodies) of the form
and
respectively. We therefore extend to
deal with these axioms in the case that is an
class:
where are variables and are constants.
Finally, we extend to deal with the
property axioms discussed in
Section 4.2:
(1) 
Using the relationships of (full) DL to FOL discussed in Section 3.1, especially Figure 4, it is straightforward to show the following.
DHL can, therefore, be viewed alternatively and precisely as an expressive fragment of defHorn  i.e., as the range of .
4.5 Expressive Power of DHL
Although the asymmetry of DHL (w.r.t. classes on different sides of axioms) makes it rather unusual by DL standards, it is easy to see that it includes (the DAML+OIL subset of) RDFS, as well as that part of DAML+OIL which corresponds to a simple frame language.
As far as RDFS is concerned, we saw in Section 4.2.1 that RDFS statements are equivalent to DL axioms of the form , , , , and , where are classes, are properties and are individuals. Given that all RDFS classes are classes (they are atomic class names), a set of DL axioms corresponding to RDFS statements would clearly satisfy the above definition of a DHL ontology.
DHL also includes the subset of DAML+OIL corresponding to simple frame language axioms, i.e., axioms defining a primitive hierarchy of classes, where each class is defined by a frame. A frame specifies the set of subsuming classes and a set of slot constraints. This corresponds very neatly to a set of DL axioms of the form .
Moreover, DHL supports the extension of this language to include equivalence of conjunctions of atomic classes, and axioms corresponding to DAML+OIL transitive property, and inverse property statements.
5 Defining DLP
A DLP is directly defined as the LPcorrespondent of a defHorn ruleset that results from applying the mapping . Semantically, a DLP is thus the fweakening of that DHL ruleset (recall subsection 3.2). The DLP expressive class is thus the expressive fsubset of DHL. By Theorem 1, DLP can, therefore, be viewed alternatively and precisely as an expressive subset of DL, not just of defHorn.
In summary, expressively DLP is contained in DHL which in turn is contained in the expressive intersection of DL and Horn.
6 More about Translating
As our discussion of expressive relationships has made clear, there is a bidirectional semantic equivalence of (1) the DHL fragment of DL and (2) the DHL fragment of defHorn. Likewise, there is a bidirectional semantic equivalence of the DLP fragment of DL and the DLP fragment of defHorn. So far, however, we have mostly concentrated on only one direction of syntactic mapping: from DL syntax to defHorn syntax (and to the corresponding defLP), rather than from defHorn (or defLP) to DL. Next, we elucidate our reasons for this emphasis.
First, a prime immediate goal for the Semantic Web is to enable rules (in LP / Horn) on top of ontologies (in DL)  more than vice versa to enable DL ontologies on top of LP or Horn rules. Second, it is desirable to exploit the relatively numerous, mature, efficient, scalable algorithms and implementations (i.e., engines) already available for LP inferencing so as to perform some fragment of DL inferencing  more than vice versa to perform LP via the fewer available DL engines, which are designed to handle more expressive languages (than DLP) and may not be optimised for DLP ontologies. Third, as compared to defHorn, DL has a relatively detailed set of quite specific syntactic expressive constructs; it was easier to go through these one by one to define a translation mapping than to do so in the reverse direction where one has to invent more structure/forms.
We do not have space here to give detailed algorithms and computational complexity analyses of the syntactic translations. We will limit ourselves to some relatively highlevel observations; these are straightforward to show. The mapping, from DL syntax to defHorn/defLP syntax, corresponds immediately to an algorithm whose computational complexity is tractable. This mapping is invertible (e.g., in the usual manner of parsers) from defHorn/defLP syntax to DL syntax, again, tractably.
7 Inferencing
As discussed in the previous section, one of the prime goals of this work is to enable some fragment of DL inferencing to be performed by LP engines. In this section we will discuss the kinds of inference typically of interest in DL and LP, and how they can be represented in each other, i.e., in LP and DL respectively. Although the emphasis is on performing DL inferencing, via our mapping translation, using an LP reasoning engine, the reverse mapping can be used in order to perform LP inferencing using a DL reasoning engine. In particular, we will show how inferencing in (the DHL fragment of) DL can be reduced, via our translation, to inferencing in LP; and how vice versa, inferencing in (the DLP fragment of) LP can be reduced to inferencing in DL.
In a DL reasoning system, several different kinds of query are typically supported w.r.t. a knowledge base . These include queries about classes:
 classinstance membership queries: given a class
,
 ground: determine whether a given individual is an instance of ;
 open: determine all the individuals in that are instances of ;
 ``allclasses'': given an individual , determine all the (named) classes in that is an instance of;
 class subsumption queries: i.e., given classes and , determine if is a subclass of w.r.t. ;
 class hierarchy queries: i.e., given a class return all/mostspecific (named) superclasses of in and/or all/mostgeneral (named) subclasses of in ;
 class satisfiability queries, i.e., given a class , determine if is satisfiable (consistent) w.r.t. .
In addition, there are similar queries about properties: propertyinstance membership, property subsumption, property hierarchy, and property satisfiability. We will call the language defined by the above kinds of DL queries.
In LP reasoning engines, there is one basic kind of query supported w.r.t. a ruleset : atom queries. These include:
 ground: determine whether a ground atom is entailed;
 open (ground is actually a special case of this): determine, given an atom (in which variables may appear), all the tuples of variable bindings (substitutions) for which the atom is entailed.
We call the language defined by the above kinds of LP queries.
Next, we discuss how to reduce querying in (the DHL fragment of) DL to querying in (the DLP fragment of) LP using the mapping . We will assume that is a ruleset derived from a DL knowledge base via , and that all queries are w.r.t. .
(ground or open) atom queries can be used to answer (ground or open) classinstance membership queries when the class is an class, i.e., is an instance of iff entails . When is an atomic class name, the mapping leads directly to a atom query. When is a conjunction, the result is a conjunction of atom queries, i.e., is an instance of iff entails and entails . When is a universal restriction, the mapping gives . This can be transformed into a atom query using a simple kind of skolemisation, i.e., is replaced with a constant , where is new in , and we have is an instance of iff entails .
The case of propertyinstance membership queries is trivial as all properties are atomic: is an instance of iff entails .
Complete information about classinstance relationships, to answer open or ``allclasses'' classinstance queries, can then be obtained via classinstance queries about all possible combinations of individuals and classes in .^{9} (Note that the set of named individuals and classes is known, and its size is worstcase linear in the size of the knowledge/rule base.)
For classes, class subsumption queries can be reduced to using a similar technique to classinstance membership queries, i.e., is a subclass of iff entails , for new in . For property subsumption queries, is a subproperty of iff entails , for new in .
Complete information about the class hierarchy can be obtained by computing the partial ordering of classes in based on the subsumption relationship.
In the DHL (and DLP) fragment, determining class/property satisfiability is a nonissue as, with the expressive power at our disposal in defHorn, it is impossible to make a class or a property unsatisfiable.
Now let us consider the reverse direction from to . In the DLP fragment of LP, every predicate is either unary or binary. Every atom query can thus be viewed as about either a named class or a property. Also, generally in LP, any open atom query is formally reducible to a set of ground atom queriesone for each of its instantiations. Thus is reducible to classinstance and propertyinstance membership queries in DL.
To recap, we have shown the following.
8 Translation to Databases
Luckily, Logic Programming is also an elegant language for dataoriented problems, for example it allows one to obtain languages equivalent to known database languages by making various syntactic restrictions. One language that can be obtained by such restrictions is Datalog, which underlies deductive databases, and closely corresponds to the defHorn subset of FOL introduced in Section 3.8.1 Translation to relational databases
Datalog programs can be implemented on top of relational databases. To perform this implementation all explicit facts of a predicate are stored in a dedicated table . All nonrecursive rules are translated to relational views. Rule bodies are translated to appropriate SQL queries (usually operating on other views). To obtain all explicit and implicit information, a view is defined to represent each predicate . The query of the view integrates the explicit information, found in with the queries that represent the bodies of those rules where is the head. The interested reader may refer to [18] for an indepth description, algorithm and proof. Intuitively, this result follows from the following substitutions: each Datalogrule can be simulated using the selectfromwhere construct of SQL; multiple rules defining the same predicate can be simulated using union; and negation in rule bodies can be simulated using not in.To compute the answer for user queries the translated views are used. This realises a form of bottom up processing, since the queries involved in view definitions are performed on the extensional data and intermediate results are propagated up to a final query, which is the user query. This results in many irrelevant facts being computed in the intermediate steps; more efficient procedures based on sideways information passing, however, have been developed in the deductive database literature.
The above mentioned strategy is, however, not possible for recursively defined rules. Here additional processing is required.
8.2 Handling recursion
Modern relational database systems, which support the SQL:99 standard, can process some limited form of recursion, namely linear recursion with a path length one. Hence, the predicate used as the rule head may occur only once in the rule body. Cycles other than such linear selfreferences can also not be implemented.Usually, binary recursive rules such as transitivity can be
rewritten into a linear form. E.g. the mapping for transitive
properties (see 1)
can be rewritten into
The usual strategy to compute the remaining forms of recursive rules in relational databases is inmemory processing using some iterative strategy, e.g. the magic template procedure [15].
Indirect Recursion
The remaining cases of nonlinear recursion that cannot be rewritten into the SQL:99 constructs are mainly represented by the possibility of having cyclical class and property hierarchies.We can, however, translate this case into the database by exploiting the observation that this form of recursion decomposes into unions, since no join processing of intermediate results (such as involved in computing the transitive closure of transitive properties) is necessary. This is immediately clear for classes, since they are monadic predicates. A closer look at all axioms where binary predicates (properties) are in the head reveals the same. Hence, these cyclic references can be implemented via an algorithm that detects equivalence classes (each constituted by a cycle) in graphs. All incoming edges to an equivalence class must be duplicated to all members of the equivalence class; this may done by using a new intermediate predicate to collect the incoming edges and deriving the members of the equivalence class from this intermediate predicate. Afterwards, all rules that constitute the cyclic references within the equivalence class may safely be removed. The reader may note that this can also be performed (with appropriate adaptions) on the cyclic references imposed by inverse properties.
8.3 Implementation
We have used the above techniques to realise a prototypical implementation of Description Horn Logic based on the Datalog engine written by Boris Motik in the KAON project. The implementation, called Bubo (after the Latin name of the biological genus of eagle owls), is freely available at http://kaon.semanticweb.org/owl/.
Initial tests of Bubo have been encouraging, but much more work needs to be done in order to determine if the benefits promised by the DLPfusion approach are delivered by this implementation.
9 Discussion
In this paper we have shown how to interoperate, semantically and inferentially, between the leading Semantic Web approaches to rules (RuleML Logic Programs) and ontologies (OWL/DAML+OIL Description Logic). We have begun by studying two new KRs, Description Logic Programs (DLP), which is defined by the expressive intersection of the two approaches, and the closely related Description Horn Logic (DHL).
We have shown that DLP (or DHL) can capture a significant fragment of DAML+OIL, including the whole of the DAML+OIL fragment of RDFS, simple frame axioms and more expressive property axioms. The RDFS fragment of DL permits: stating that a class D is a Subclass of a class E; stating that the Domain of a property P is a class C; stating that the Range of a property P is a class C; stating that a property P is a Subproperty of a property Q; stating that an individual b is an Instance of a class C; and stating that a pair of individuals (a,b) is an Instance of a property P. Additional DLP expressively permits (within DL): using the Intersection connective (conjunction) within class descriptions (i.e., in C, D, or E above); using the Union connective (disjunction) within subclass descriptions (i.e., in D above); using (a restricted form of) Universal quantification within superclass descriptions (i.e., in E above); using (a restricted form of) Existential quantification within subclass descriptions (i.e., in D above); stating that a property P is Transitive; stating that a property P is Symmetric; and stating that a property P is the Inverse of a property Q.
Many of the ontologies in the DAML ontology library are inside this fragment of DAML+OIL. An immediate result of this work is that LP engines could be used for reasoning with these ontologies and for reasoning with (possibly very large numbers of) facts, such as web page annotations, that use vocabulary from these ontologies.
This work represents only a first step in realising a more complete interoperability between rules and ontologies, and the layering of rules on top of ontology languages in the Semantic Web ``stack''. We were able to illustrate its utility both theoretically and within our prototypical implementation. We believe, however, that our study of the expressive intersection will provide a firm foundation for future investigations of more expressive languages up to and including the expressive union of rules and ontologies.
Future work will include extending the mapping to additional DL primitives, in particular those which require the ability to state and derive the equality of individuals, such as cardinality restrictions (including functional properties) and nominals (extensionally defined classes).
Acknowledgements
Thanks to Tim BernersLee, Harold Boley, Dan Connolly, Michael Dean, Richard Fikes, Patrick Hayes, Jim Hendler, Deborah McGuinness, Boris Motik, Daniel Oberle, Peter PatelSchneider, Jos De Roo, Steffen Staab and members of the DAML+OIL Joint Committee for helpful comments and discussions.
Bibliography
 1
 F. Baader, D. Calvanese, D. McGuinness,
D. Nardi, and P. PatelSchneider, editors.
The Description Logic Handbook.
Cambridge University Press, 2002.  2
 C. Baral and M. Gelfond.
Logic programming and knowledge representation.
Journal of Logic Programming, 19/20:73148, 1994.  3
 H. Boley, B. Grosof, M. Sintek, S. Tabet,
and G. Wagner.
RuleML Design , September 2002.
http://www.dfki.unikl.de/ruleml/indesign.html.  4
 A. Borgida.
On the relative expressiveness of description logics and predicate logics.
Artificial Intelligence, 82(12):353367, 1996.  5
 D. Calvanese, G. De Giacomo, and
M. Lenzerini.
On the decidability of query containment under constraints.
In Proc. of PODS'98, pages 149158, 1998.  6
 D. Connolly, F. van Harmelen, I. Horrocks,
D. L. McGuinness, P. F. PatelSchneider, and L. A.
Stein.
DAML+OIL (March 2001) Reference Description, December 2001.
http://www.w3.org/TR/daml+oilreference/.  7
 F. M. Donini, M. Lenzerini, D. Nardi, and
W. Nutt.
The complexity of concept languages.
In Proc. of KR'91, pages 151162, 1991.  8
 W. Dowling and J. Gallier.
Linear time algorithms for testing the satisfiability of propositional horn formulae.
Journal of Logic Programming, 3:267284, 1984.  9
 E. Grädel.
On the restraining power of guards.
J. of Symbolic Logic, 64:17191742, 1999.  10
 V. Haarslev and R. Moller.
Description of the RACER system and its applications.
In DL2001 Workshop on Description Logics, Stanford, CA, 2001.  11
 I. Horrocks and U. Sattler.
Ontology reasoning in the (D) description logic.
In Proc. of IJCAI 2001, pages 199204, 2001.  12
 I. Horrocks, U. Sattler, S. Tessaris, and
S. Tobies.
How to decide query containment under constraints using a description logic.
In Proc. of LPAR'2000, 2000.  13
 I. Horrocks, U. Sattler, and S. Tobies.
Practical reasoning for expressive description logics.
In Proc. of LPAR'99, pages 161180, 1999.  14
 J. W. Lloyd.
Foundations of logic programming (second, extended edition).
Springer series in symbolic computation. SpringerVerlag, New York, 1987.  15
 R. Ramakrishnan.
Magic templates: A spellbinding approach to logic programs.
J. Logic Programming, 11:189216, 1991.  16
 K. Sagonas, T. Swift, and D. S. Warren.
XSB as an efficient deductive database engine.
In R. T. Snodgrass and M. Winslett, editors, Proc. of the 1994 ACM SIGMOD Int. Conf. on Management of Data (SIGMOD'94), pages 442453, 1994.  17
 K. Schild.
A correspondence theory for terminological logics: Preliminary report.
In Proc. of IJCAI'91, pages 466471, 1991.  18
 J. D. Ullman.
Principles of Database and Knowledgebase Systems, volume 1.
Computer Science Press, 1988.  19
 M. Y. Vardi.
Why is modal logic so robustly decidable?
In N. Immerman and P. Kolaitis, editors, Descriptive Complexity and Finite Models. American Mathematical Society, 1997.
About this document ...
Description Logic Programs: Combining Logic Programs with Description LogicThis document was generated using the LaTeX2HTML translator Version 2K.1beta (1.50)
Copyright © 1993, 1994, 1995, 1996,
Nikos
Drakos, Computer Based Learning Unit, University of
Leeds.
Copyright © 1997, 1998, 1999,
Ross Moore,
Mathematics Department, Macquarie University, Sydney.
The command line arguments were:
latex2html numbered_footnotes split 0
p117grosof
The translation was initiated by on 20030328
Footnotes
 ... RuleML.^{1}
 In tandem with RuleML/LP, we also focus on the (positive) Horn subset of FOL, which is closely related to the positive Horn subset of LP.
 ... relationships).^{2}
 Equivalence axioms can be reduced to a symmetrical pair of inclusion axioms.
 ... ``normal''^{3}
 In [2] this is called ``general''; however, there are actually a number of frequently used extensions!
 ... it.^{4}
 The Datalog restriction is usually taken to mean, additionally, no negation and only ``safe'' rules (all variables in the head also occur in the body).
 ...vardi97why.^{5}
 Expressive features such as transitive properties and the oneOf constructor compromise the tree model property to some extent, e.g., transitive properties can cause ``shortcuts'' down branches of the tree.
 ... captured.^{6}
 This is not an inherent restriction, and nary DLs are known, e.g., [5].
 ....^{7}
 Note that, technically, this is partialfunctionality as for any given there is no requirement that there exist a such that .
 ... provided.^{8}
 Note that this feature is not supported in the RDFS subset of DLs.
 ....^{9}
 More efficient algorithms would no doubt be used in practise.