pdfs.semanticscholar.org · the f(rames)-logic approac h for description languages i i: a hybrid in...
TRANSCRIPT
The F(rames)-Logic Approach for Description Languages II: A
Hybrid Integration of Rules and Descriptions
Mira Balaban
Dept. of Mathematics and Computer Science
Ben-Gurion University of the Negev
P.O.B. 653, Beer-Sheva 84105, Israel
(972)-7-461622
Technical Report FC-94-10
Abstract
Descriptions andRules are di�erent, complementary, essential forms of knowledge. Descriptions are
analytic and closed; rules are contingent and open. Historically, descriptions and rules were developed
along separate lines, by di�erent communities. The two forms can be integrated either by compiling
one form within the other, or by constructing a hybrid framework. The hybrid solution keeps the
modular independent status of each approach, but needs an underlying integration framework, in which
a coherent compositional semantics can be de�ned.
In this paper we use F-Logic as an underlying framework for a hybrid construction of descriptions
and rules. The hybrid framework, termed DFL, is modular, and enjoys a compositional semantics.
In DFL, the knowledge base manages a database of explicit descriptions, by consulting two separate
reasoners: DL { The Description Languages reasoner, and R { The Rules reasoner. The reasoners
can operate under di�erent semantical policies. Four di�erent compositional semantics possible for the
hybrid DFL framework are discussed and compared.
The DFL account for DLs is, markedly, di�erent from the standard embedding of DLs in FOL,
where descriptions are translated into collections of FOL formulae, thereby losing the independent
special status of descriptions and operators.
keywords: Knowledge representation, Description languages, Rules, Hybrid knowledge bases, Object-
oriented representation, F-Logic.
1 Introduction
Descriptions and Rules are di�erent, complementary, essential forms of knowledge. Descriptions are
analytic and closed; rules are contingent and open. Historically, descriptions and rules were developed
along separate lines, by di�erent communities. The two forms can be integrated either by compiling
one form within the other, or by constructing a hybrid framework. The �rst solution yields a coherent
framework, but requires reconstruction of one approach within the other, and makes one approach sub-
ordinate to the other. The hybrid solution keeps the modular independent status of each approach, but
needs an underlying integration framework, in which a coherent compositional semantics can be de�ned.
In this paper we use F-Logic as an underlying framework for a hybrid construction of descriptions and
rules. The hybrid framework follows two major principles:
� Modularity of the source forms of knowledge.
� Compositional semantics, i.e., the semantics is composed from the separate semantics of the
source forms.
Two other desirable principles are:
� Query sensitivity, i.e., the semantics should re ect expected query-answering behavior.
� Preserve intrinsic properties of the source forms, e.g., openness for rules.
Description languages (DLs) is a collective name for knowledge representation formalisms that
concentrate on the management of essential descriptive vocabulary. It rests on the observation ([15]) that
the natural ontology for providing information about a domain requires the ability to de�ne, organize,
and use intensional entities that stand for concepts and roles in a domain. The main construct of DLs
is the description, which is a complex term built on top of a �xed set of description (terminological)
operators, and denotes concepts or roles ( [3,4,32,47,12,41,36,38,63] ). The status of descriptions, and
the emphasis on direct semantics is the major distinction between DLs to other logics in AI.
Rules are traditionally used in deductive database and in expert systems, as a means for express-
ing implicit knowledge, that extends the explicitly given facts. In DLs, although there is a growing
agreement that rules are essential, there is no agreement on an integration framework, and the stan-
dard formal treatment is restricted to descriptions. Indeed, some systems (like [55,29]), manipulate also
terminological rules, but they are added on a procedural-operational basis, and are not used for reason-
ing with analytic descriptions, or in the contrapositive direction. The formal status of rules within such
systems is opaque. Other approaches try to compile rules into the DL approach ([19], where epistemic
operators added to a concept language are used, among other things, to simulate the behavior of termi-
nological rules), or to compile a DL into a rules framework ([26], where a DL classi�cation mechanism is
integrated into a �rst order logic programming language).
F(rames)-Logic ( [31,30] ) is a full- edged logic, designed for reasoning about intensional object-
oriented domains. It assumes an ontology of objects that form a hierarchy, and are also inter-related by
a membership relation. Information about the objects is given in methods or attributes that are attached
to objects, and in types of these methods. F-Logic provides means for typing and type checking, and sup-
ports reasoning about inheritance of types and of methods. Its syntax allows for high order constructs,
like quanti�cation over methods, but its semantics is carefully kept �rst order, since quanti�cation is
1
restricted to namable methods alone. A sound and complete proof theory is given in[31].
In a previous paper ([9]) F-Logic is suggested as a platform for the development and investigation of
description languages. The advantages are:
� A unifying (standard) DL framework.
� Extended expressivity.
� Smooth integration with other approaches.
In [9] we argue that F-Logic can serve as a unifying formalism for current description languages.
In particular it is shown that it provides a faithful account, in terms of direct syntax, semantics and
inference algorithms, to current DLs. A DL knowledge base, under this account, reasons about a data
base of descriptions, by consulting an \oracle" of axiomatizations of DL operators. The semantics of the
knowledge base depends on the descriptions and the oracle. Inference can be accomplished using any
specialized DL inference algorithm, that is faithful to the semantics. It is shown that proper axioma-
tizations of DL operators exist for meaningful DLs, and that standard inference algorithms are indeed
applicable, under these conditions. Another point discussed in detail in [9] is the extended expressivity
that is gained. However, the introduction of new DL operators requires the development of new inference
algorithms.
In this paper we introduce DFL, a hybrid representation framework, that integrates descriptions and
rules, based on this approach. In DFL, the knowledge base manages a database of explicit descriptions
(a terminology and assertions). The knowledge base reasons about the given descriptions by consulting
two separate reasoners: DL { The Description Languages reasoner, and R { The Rules reasoner. The
DFL framework is hybrid since it employs two di�erent, independent reasoners, that can operate under
di�erent semantical policies. Problems of mismatch among the di�erent components are avoided due to
the common underlying semantics of F-Logic.
The DFL account for DLs is, markedly, di�erent from the standard embedding of DLs in FOL, where
descriptions are translated into collections of FOL formulae, thereby losing the independent special status
of descriptions and operators. The translated formulae have no syntactical characterization: Description
operators are lost, and descriptions cannot be separated, on a syntactical basis, from other informational
constructs, e.g., rules. The FOL account for DLs, does not allow for a modular mode of operation, where
di�erent reasoners manipulate a shared database of descriptions, in di�erent ways.
In the rest of this paper we, �rst, present our intuitions about the architecture and mode of operation of
a hybrid DFL knowledge base, by following the industrial plants example, from the BACK manual ([29]).
Then, we shortly introduce DLs (3) and F-Logic (4). In 5 we summarize our results from [9] concerning
the proper account that F-Logic can provide to DLs. Section 6 presents four di�erent compositional
semantics possible for the hybrid DFL framework, and compares their advantages and weaknesses, with
respect to the stated above principles of hybrid integration. Appropriate inference methods are, shortly,
discussed in Section 7. Section 8 is the conclusion and discussion of future research.
2
2 Architecture and Mode of Operation of a DFL Knowledge Base {
An Example
2.1 Architecture
A DFL knowledge base manages a database of explicit descriptions (a terminology and assertions). The
knowledge base reasons about the given descriptions by consulting two separate reasoners:
1. DL { The Description Languages reasoner: A decidable reasoner, that reasons on the basis of the
intended meaning of the terminological operators that form the descriptions.
2. R { The Rules reasoner, that reasons on the basis of given rules and some agreed upon semantical
policy (e.g., perfect model).
This architecture is described in the following �gure:
DFL MANAGER
%. &-
R $ D { DESCRIPTIONS DATABASE $ DL
While in query mode the DFL manager dispatches queries to the two reasoners. The reasoners
make e�orts to answer. If they succeed, they return an answer(s) to the manager. While reasoning, the
reasoners may �nd out new descriptions, which they add directly to the database. The DL reasoner can
operate under the so called Open World Assumption (OWA), while the R reasoner can adopt the more
conventional Closed World Assumption (CWA).
The DFL framework di�ers from most research into strengthening DLs. The works of, for example
[53,6,7,19,45] try to extend or augment standard DLs with AI techniques/mechanisms such as preferntial
semantics, default rules, and epistemic and other modal operators. We prefer to strengthen DLs by
combining their standard form with other standard AI mechanisms, using F-Logic as an underlying
uniform, integration basis. This way we save the need to redevelop existing tools. We claim that the
DFL framework gets closer to the idea of rational management of [20].
2.2 Mode of Operation
We demonstrate our intuitions about the mode of operation of a hybride DFL knowledge base, using the
industrial plants example from the BACK manual ([29]).
The descriptions database, D, is given in tables 1 and 2, below. Table 1 includes the terminology
descriptions, and Table 2 includes the assertion descriptions. We use a more or less standard notation
for descriptions. The term is a in Table 1 stands for is a subconcept of .
We assume that the DL reasoner has a decidable oracle for answering queries about descriptions
built with the operators: and, all, some, (primitive-)not, domain, range, inv, trans, comp
1
. The
R reasoner consults the following rules:
r1: A terminological rule: A radioactive material that is also a waste, is a toxic waste.
X 2 toxic waste � X 2 and(radioactive material; waste):
1
After consulting Franz Baader and Klaus Schild ([5,58]), I realize that it is not clear whether this collection of operators,
where and is used for concepts' and for roles' conjunction, yields a decidable DL. However, I prefer to leave the example as
is.
3
Kind No. Description in words description
Primitive- t1) product is a top product � top
concept t2) place is a top place � top
t3) type is a top type � top
t4) degree is a top degree � top
t5) danger degree is a degree danger degree � degree
t6) energy is a product energy � product
t7) mechanical product is a product mechanical product � product
t8) safe product is a product safe product � product
t9) dangerous product is a product dangerous product � product
t10) material is a product, but not an
energy material � and(product;not(energy))
t11) waste is a product, but not an energy waste � and(product;not(energy))
t12) radioactive material is a material radioactive material � material
t13) safe material is a material safe material � material
t14) toxic waste is a waste toxic waste � waste
t15) chemical waste is a material chemical waste � and(
and is a waste material; waste)
t16) plant is a top that is located at plant � and(top; all(located at; place);
place and has a type all(is of type; type))
Primitive- t17) A plant produces products, or, produces � and(domain(plant);
role produces is a relation between plants range(product) )
and products
t18) A product may be buried at a place buried at � and(domain(product);
range(place) )
t19) located at is a relation between
objects and places located at � range(place)
t20) A product may directly contain directly contains � and(
products domain(product); range(product))
t21) degree of is a relation between degree of � and(domain(product);
products and degrees range(degree) )
De�ned- t22) A mechanical plant is a plant that mechanical plant
:
= and(plant;
concept produces only mechanical products all(produces;mechanical product))
t23) A dangerous plant is a plant that dangerous plant
:
= and(plant;
produces a dangerous product some(produces; some(
degree of; danger degree)))
t24) A risky place is a place where risky place
:
= and(place; some(
a toxic waste is buried at inv(buried at); toxic waste))
De�ned- t25) produced by is inverse of produces produced by
:
= inv(produces)
role t26) contains is the transitive closure
role of directly contains contains
:
= trans(directly contains)
t27) uses up is the composition of uses up
:
= and(
produces and contains, restricted comp(produces; contains);
to materials as the range concept range(material) )
Table 1: Tbox { Terminology
4
Kind No. Description in words description
Concept- a1) plant
1
is a mechanical plant plant
1
2 mechanica plant
member a2) waste
2
is a wast which is a
radioactive material waste
2
2 and(wast; radioactive material)
a3) product
1
is a chemical waste product
1
2 chemical waste
Role- a4) waste
1
is a waste product of plant
1
(plant
1
; waste
1
) 2 produces
member a5) plant
1
produces a product product
2
(plant
1
; product
2
) 2 produces
a6) plant
2
produces a product product
1
(plant
2
; product
1
) 2 produces
a7) waste
1
is buried at place l (waste
1
; l) 2 buried at
a8) waste
2
is buried at place dump (waste
2
; dump) 2 buried at
a9) plant
1
is located at dump (plant
1
; dump) 2 located at
a10) product
2
directly contains product
1
(product
2
; product
1
) 2 directly contains
a11) The degree of ecology mindedness
is high (ecology mindedness; high) 2 degree of
Table 2: Abox { Assertions
r2: A place L in which a product of a dangerous plant is buried at, is a risky place.
L 2 risky place � Y 2 dangerous plant; (Y;X) 2 produces; (X;L) 2 buried at:
r3: If a plant is located at a risky place, it is a dangerous plant.
Y 2 dangerous plant � Y 2 plant; (Y;X) 2 located at; X 2 risky place:
r4: A rule with negation: If a plant uses up a material that cannot be shown to be a dangerous product,
it can be assumed to be a safe material.
X 2 safe material � Y 2 plant; (Y;X) 2 uses up; not(X 2 dangerous product)
2
.
r5: A rule with negation: A mechanical product that cannot be shown to be buried at some place, can
be assumed to be a safe product.
X 2 safe product � X 2 mechanical product; not( (X;L) 2 buried at ):
r6: A rule that extends the terminology: If ecology mindedness is high, then chemical waste is a
dangerous product.
chemical waste � dangerous product � (ecology mindedness; high) 2 degree of:
r7: A rule that extends the terminology
3
: If ecology mindedness is high, then if a plant produces a
dangerous product, then all of its products are considered dangerous products.
some(produces; dangerous product) � all(produces; dangerous product) �
(ecology mindedness; high) 2 degree of:
2
Note that this not operator is the F-Logic's negation as failure operator, and not the DL negation operator on primitive
concepts (as in t11 and t12, for example). The distinction can be made on a syntactical basis.
3
This rule is outside the consensus of DLs, where essential relationships between DL terms derive from the �xed meaning
of the DL operators, and not from contingent knowledge.
5
Reasoning:
The reasoning process is conducted by the DFL manager, that dispatches queries to the two reasoners.
The queries are descriptions that might include variables, and the reasoners are expected to provide
instantiations to the variables, in case of a positive answer. We assume that the DFL manager adds the
answers of the reasoners to the database D.
1. Iteration between the reasoners:
No Query Reasoner Answer Justi�cation
q1) ?X 2 mechanical product DL X := waist
1
(t22); (a1); (a4)
q2) ?X 2 mechanical product DL X := product
2
(t22); (a1); (a5)
q3) ?X 2 toxic waste R X := waste
2
(r1); (a2)
q4) ?X 2 risky place DL X := dump (t24); (t18); (a8); (q3)
q5) ?X 2 dangerous plant R X := plant
1
(r3); (t22); (a1); (a9);
(q4)
q6) ?X 2 risky place R X := l (r2); (q5); (a4); (a7)
q7) ?(X; Y ) 2 contains DL X := product
2
; Y := product
1
(t26); (a10)
q8) ?(X; Y ) 2 uses up DL X := plant
1
; Y := product
1
(t27); (a5); (q7); (a3);
(t15)
2. Reasoning with rules with negation:
No Query Reasoner Answer Justi�cation
q9) ?X 2 safe material R X := product
1
(r4); (a1); (t22); (q8)
q10) ?X 2 safe product R X := product
2
(r5); (q2)
3. Reasoning with rules that extend the terminology:
No Query Reasoner Answer Justi�cation
q11) ?X 2 dangerous product R X := product
1
(r6); (a11); (a3)
q12) ?X 2 some(produces; dangerous product DL X := plant
2
(a6); (q11)
q13) ?X 2 all(produces; dangerous product R X := plant
2
(r7); (a11); (q12)
Note that the order of rules' application matters. If r6 is consulted before r4, then q9 cannot be
concluded. Hence, the reasoning process is time dependent: It may be the case that at a certain
point a reasoner is unable to answer a query or to add new descriptions, but at a later moment,
based on new descriptions provided by the other reasoner, the reasoner can do \something".
3 Description Languages
Description languages form a spino� of the KL-ONE school ([17,64]), that concentrates on languages
that provide constructs for management of analytic domain terminology. DLs emphasize the importance
of direct, well de�ned semantics, and of a limited, but tractable, inferential service. DLs assume that
a typical domain's terminology is built around concepts and roles, which stand for subsets and binary
relations over a domain of individuals, respectively. The concepts are assumed to form a taxonomy, i.e.,
6
a partially ordered structure that is derived from the lattice of subsets. Accordingly, the alphabet of
a DL includes an unlimited supply of symbols for concepts, roles and individuals, and a small set of
term forming operator symbols. Descriptive terms are formed by applying term forming operators to
concept/role symbols. For example, the concept of a frozen-dinner, i.e., a ready-made evening meal,
whose courses are all frozen, and at least one is spicy, can be described by the concept term:
and( ready-made-meal;
some(eating-time; evening);
all(course; and(food; some(form; frozen); all(form; frozen)));
some(compose(course; taste); spicy))
(1)
In this term ready-made-meal is a concept symbol, intended to represent the concept of a ready made
meal; eating-time is a role symbol, intended to represent the role (binary relation) of eating time;
some(eating-time; evening), is a concept term that represents the concept of all elements that are
related via eating-time to some element from the evening concept; all(form; frozen) is a concept term
that represents the concept of all elements that are related via the form role only to elements of the
frozen concept; compose(course; taste) is a role term that represents the composition of the course and
taste roles.
A terminology is formed by associating concept/role symbols with de�nitions, which are descriptive
terms. For example, the above concept term can be used to de�ne the de�ned-concept symbol frozen-
dinner. The de�ned-role symbol course.taste can be de�ned as the composition of the course and taste
roles:
frozen-dinner
:
= hterm 1i
course:taste
:
= compose(course; taste)
The terminology usually allows for the introduction of primitive concept/role symbols, for which only
necessary conditions are given. For example, evening can be a primitive concept symbol characterized
as a time, and taste can be a primitive role symbol described as a sort of characterization:
evening � time
taste � characterization
Most DLs concentrate on de�ned concepts, and include only limited capabilities for forming non-atomic
role terms (if at all).
A typical DL knowledge base has two distinguished components: A Terminological KB, or T-box,
that manages the concept/role de�nitions, and an Assertional KB, or A-box, that manages knowledge
about individual concrete objects. For example, the A-box might include:
dinner:9:5 2 frozen-dinner
(dinner:9:5; sunset) 2 eating-time
which assert an individual that belongs to the frozen-dinner concept, and has sunset as its eating-time.
The overall structure of a typical DL knowledge base is given in Table 3.
Various systems allow terminological rules, introduced on an operational basis. For example:
frozen-dinner �! lousy-meal
good-violin-player �! good-hearing
are rules that assert that all frozen-dinners are also lousy-meals, and all good-violin-players are also
individuals with a good-hearing. These rules provide non-de�nitional information about frozen dinners
7
D
Tbox Abox
DEFs PRIMITIV ES C members R members
c
n
:
= c c
1
� c
2
o 2 c (o
1
; o
2
) 2 r
r
n
:
= r r
1
� r
2
Table 3: The Structure of a Typical DL KB.
and violin players. They are used for extending descriptions of individuals (e.g., if Mary is a good
violin player, she also has a good hearing), but not for reasoning with analytic descriptions, or in the
contrapositive direction.
The currently standard semantics of DLs is set theoretic: Concept terms are interpreted as denoting
sets of domain elements, role terms denote binary relations over the interpretation domain, individual
objects denote elements in the domain, de�nitions are interpreted by set equality, and assertions are
interpreted by membership. Formal de�nition of description languages and their semantics is given in
Appendix A.
DLs are unique in their provisions for specialized management of complex descriptions. Claimed
possible embeddings of DLs in classical logic ( e.g., [27] ) lose the direct semantics of complex descriptions,
which is the bare bone of DLs
4
. That is, DLs can be embedded in classical logic, but the resulting classical
language is not a DL, as descriptions are translated into collections of independent assertions.
The central management service provided by a description KR system is the automatic classi�cation
of concepts (roles) into their proper position in the taxonomy, based on their descriptions. The taxonomy
is used for answering queries about the inter-relationships between concepts/descriptions, about the prop-
erties of concepts and individuals, and about membership of individuals in concepts. The conventional
method is to classify, i.e., �nd the proper position in the taxonomy, for every description that appears
in a query. The answer to the query, then, results from observing possible subsumption relationships
between concepts/descriptions that appear in the query, based on their relative position in the taxonomy.
Inferencing in DLs is essentially di�erent from standard inference in AI, or in logic databases. The
main point of diversion is that DL systems consider de�nitions in the vocabulary, not a temporary
population in a knowldege base. For example, the query:
Are all children of c doctors?
is understood as an essential query about c. That is, this query is understood as the query:
Is c subsumed by all(child, doctor) ?
and not as the query:
Are all known children of c members of the doctor concept?
The latter query, demonstrates the typical database and AI approaches, that operate under the Closed
World Assumption. In contrast, DLs can be understood as operating under the Open World Assump-
tion, where a momentary population in a knowledge base does not provide su�cient evidence on essential
4
The Omega system of [3,4] is an exception since it is a classical logic description-calculus, based in the notions of
inheritance and attribution.
8
de�nitions in the terminology. DLs are unique in developing knowledge bases for essential domain vo-
cabularies.
Determination of subsumption between concepts' (roles') descriptions is the main inferential task,
since all other inferential operations are reduced to subsumption. Hence, major e�orts were devoted to
the study of the subsumption problem in the context of di�erent terminologies ([33,48,59,43]), to the
study of subsumption/classi�cation algorithms in existing systems ([8,41]), and to the development of
subsumption algorithms ([55,28,1].
The conclusion of this intensive study of subsumption is that keeping subsumption sound, complete,
and tractable is not feasible, and some criteria must be relaxed. That is, in order to keep the subsump-
tion problem tractable, the set of term forming operators has to be severely limited ([59,47,33]). [42]
lists known complexity results for subsumption, and for subsumption algorithms in di�erent systems.
CLASSIC ([12]) is a formal, well de�ned system with limited expressivity, but tractable and complete
inference machinery. Nevertheless, growing experience with existing systems shows that the idea of a
small, tractable and complete DL component that will be integrated within a larger knowledge base
system (as suggested in [47]) is not realistic, mainly since users of a restricted DL knowledge base use
ad-hoc methods that jeopardize the soundness of the whole system ([20]). The LOOM system ([37]),
takes a contrary approach to that of CLASSIC: It emphasizes the strong expressivity of the language,
at the expense of completeness. The BACK system ([34,35]) is a formal, well de�ned system, which is
more expressive than CLASSIC, with an incomplete subsumption algorithm. [8] reports on experiments
in approximating completeness in an expressive DL.
There is a growing agreement that DLs should be strengthened to meet more faithfully users' re-
quirements ( [63,39,61,63,10,24,52,23,53,6,46,49,20,36,38,44,60,56,25,51,40,11] ). Expectations include:
Wider expressivity, uniform inference theory, integration with other representation frameworks. A recent
ongoing e�ort to standardize description languages is reported in [50].
4 F-Logic
An F-Logic domain U consists of objects and methods. In addition, there are object constructors, which
are functions de�ned on objects, a partial ordering �
U
on objects, that stands for the subset relationship,
and a binary relation 2
U
on objects, that stands for the membership relationship. A condition set on �
U
and 2
U
guarantees that membership in an object is extended to a super-class object. The underlying
intensional approach assumes that the \essence" of an object lies in its behavior. Hence, objects can be
just anything that we wish to talk about, like Mary, Mary
0
s car, the cars of Ben-Gurion University
employees, and the role of being amother. In particular, there is no a priori distinction between individual
to class objects, i.e., an object can be both, depending on its behavior/relationship to other objects. If
o
1
� o
2
, then o
1
is understood as a subset of o
2
; if o
1
2 o
2
, then o
1
is understood as a member of o
2
(the
subscript U is omitted, for simplicity). This approach is particularly powerful, since a collective entity
can be viewed, both, as a class of objects, and as an individual object, that can be a member of another
(class viewed) object. Another advantage is that a singleton is identi�ed with its member. For example,
the following \chains" of 2, � relations can be present in U :
maryAsChild � mary 2 studentCommittee
(
� student
2 univCommittee
Of course, a distinction between individuals to classes (concepts), and other distinctions can be enforced
by imposing sorts.
9
Methods are partial functions of objects. There are single-valued (scalar) and set-valued methods.
Methods describe the behavior of objects, and provide information about objects. For example, spouse-of,
children-of, and information on a bank-account, can be captured by methods. The children-of method is
an example of a method that takes additional arguments: \children-of an object o
1
with another object
o
2
", is an application of the method on o
1
, with o
2
as an extra argument (or in the context of o
2
). A
method like spouse-of, that does not take additional arguments (i.e., a function of one argument) is called
an attribute. Name-of, age-of, address-of, are all attributes. Methods that describe actions, like buy, meet,
treat, etc., can typically take additional arguments, for all the parameters of the actions. These are n-ary
functions, (n > 1).
Methods are also classi�ed into inheritable and non-inheritable. For example, color is an inher-
itable attribute of bear, averageSalary is a non-inheritable attribute of faculty, and children-of is a
non-inheritable set-valued method of Mary (since various specializations of Mary, e.g., MaryAsChild
need not inherit the value of children-of atMary). The inference machinery uses the distinction between
inheritable to non-inheritable methods for propagating values of inheritable methods, down the � hierar-
chy, as long as no overwriting is caused. Inheritance extends also into the 2 relationship, but is blocked
after one step. This way, Mary, being a student, inherits the registered-in-college attribute-value pair,
while its MaryAsChild specialization does not inherit this property; studentCommittee can inherit the
committee-size property of univCommittee, but inheritance does not extend to Mary.
The \secret" behind F-Logic is the high-logization of methods: Methods and types are rei�ed by their
object-names, and quanti�cation over them is carried just over their object-names. Appendix B shortly
summarizes the main ideas in the semantics of F-Logic.
The following table summarizes the correspondence between DLs' roles to F-Logic's methods:
DLs F-Logic
n-ary feature single-valued method
n-ary role set-valued method
(binary) feature single-valued attribute
(binary) role set-valued attribute
4.1 F-Logic Syntax
The terms of F-Logic are expressions that denote objects in the domain. For example, mary, 3,
and(polygon, 3Sides), and(polygon, 3Angles), cars-of(employees(bgu)), are id-terms, denoting objects.
The id-terms and(polygon, 3Sides) and and(polygon, 3Angles) may denote two distinct intensional ob-
jects with the same extension, i.e., the set of triangles. In the above id-terms, and, employees, and
cars-of are object constructors: They denote total functions on the domain U , that map objects to ob-
jects. Variables can also appear in id-terms, as in classical �rst order logic (we use capital �rst letters to
denote variables).
The atomic formulae of F-Logic, called F-molecules, are of three kinds: is-a F-molecules, data F-
molecules, and signature F-molecules.
1. Is-a F-molecules map to the partial ordering, and to the membership relation on U . For example,
10
Is-a F-molecules Meaning
mary : woman The object denoted by mary is 2
U
related to the one denoted by woman.
woman :: person The object denoted by woman is �
U
related to the one denoted by person.
and(polygon, 3Sides) Subset relationship (�
U
) between the denotations of the two id-terms.
:: polygon
Is-a F-molecules remind concept introductions and object assertions in DLs. That is, the F-Logic
symbols :: and : are similar to the � and 2 symbols in DLs, respectively.
2. Data F-molecules are assertions about the values that methods (features, roles) get on objects. For
example:
Data F-molecules Meaning Explanation
mary[ husband-of ! fred ] Fred is Mary's husband. husband-of is an attribute-.
feature
bear[ color �! grey ] Bears are grey. color is an inheritable attribute-.
feature
mary[ teach !! faut., graph.g] Mary teaches aut. & graph. teach is an attribute-role.
bear[ color @ north �! white] Northern bears are white. color is an inheritable non-.
attribute-feature
son(m)[children@j !! fpatg] Pat is a child of m's son with j. children is a non-attribute-role.
Data F-molecules remind role assertions in DLs. The molecule
o
1
[m@par
1
; . . . ; par
n
; o
2
] (n � 0)
is similar to the n+ 2-ary (n � 0) role assertion
(o
1
; par
1
; . . . ; par
n
; o
2
) 2 m;
where ; stands for one of the arrows !; �!; !!; �!!. The di�erent arrows characterize the
method as being single-valued, set-valued, inheritable single-valued, or inheritable set-valued.
3. Signature F-molecules are assertions about the types of features and roles. For example,
X[ husband-of ) (male) ]
X[ children @ Y )) (person) ]
where X and Y are assumed to be universally quanti�ed, assert that values of the husband-of feature
must be males, and the values of the children role must be of type person. The rule:
X : and( female, married ) � X[ husband-of ) () ]
where X is assumed to be universally quanti�ed, asserts that if the feature husband-of applies to
an object o denoted by X, then o must be a member of the and( female, married ) class, i.e., a
married female
5
.
F-Logic includes also regular atomic formulae of a �rst order language. Its formulae are constructed
using connectives and quanti�ers in the usual �rst order manner. Appendix (B) presents several examples,
and provides a short account of F-Logic's semantics.
5
A rule is an implication whose conclusion is an F-molecule.
11
5 F-Logic as a Uniform, Expressive and Faithful Platform for the
Development and Management of Description Languages
This section summarizes our results from [9], where we showed that standard DL's are natural subsets
of F-Logic. This claim includes three points:
1. Direct semantics { Standard terminological operators have direct meaning in F-Logic. This meaning
can be axiomatized, independently from any usage of these operators in descriptions. Hence, the
descriptional nature is preserved. Note that this is, markedly, di�erent from the standard embedding
of DLs in FOL.
2. Semantics' account { F-Logic's object-oriented semantics provides a proper account for DLs' set-
theoretic semantics. In particular, subsumption relations between descriptions are preserved.
3. Inference's account { Standard DLs' subsumption algorithms are correct in F-Logic. Hence, since
descriptions preserve their independent status, DLs' algorithms can be used as specialized, direct
inference tools.
In addition, we showed that F-Logic can support desired extended expressivity in DLs.
5.1 Direct Semantics
The objects in an F-Logic's ontology are the counterpart of concepts in a DL's ontology. The partial
ordering �
U
stands for concept subsumption, and the binary relation 2
U
stands for membership of an
object in a concept. The methods in an F-Logic's ontology are the counterpart of roles in a DL's ontology.
Standard terminological operators have direct meaning in F-Logic's ontology. For example,
� The and terminological operator is the greatest-lower-bound (glb) operator on the taxonomy
(U;�
U
).
� The all operator is a type restriction on a role.
� The at-least, at-most, and some operators are cardinality restrictions on roles, etc.
We show, for several most standard terminological operators, how they can be axiomatized in F-Logic.
The axiomatization applies to the operators themselves, and not to descriptions where these operators
are used. The axiomatization can be used as an \oracle", with which a DL reasoner consults. In
other words, the F-Logic's account for DLs replaces the built-in meaning of terminolgical operators by a
\terminological oracle", without a�ecting the descriptions themselves. The modular status of descriptions
allows other reasoners to manipulate the descriptions, independently from the meaning of the operators.
[and] The object constructor and denotes the glb operator on (U;�
U
). It can be axiomatized as follows:
X :: and( C
1
; . . . ; C
n
) �
n
^
i=1
( X :: C
i
)(2)
Note that and is an object constructor, and that it can have changing arity
6
, while
V
is the regular
conjunction connective. An alternative axiomatization using rules is also presented in [9].
6
The changing arity is supported by the Hilog enhancement to F-Logic [18].
12
The extension of and( C
1
; . . . ; C
n
), i.e., the objects related to it via 2, can be characterized as
the intersection of the extensions of the C
i
-s, as follows:
X : and( C
1
; . . . ; C
n
) �
n
^
i=1
( X : C
i
)(3)
[exists] The concept forming operator exists, selects all objects on which a (set-valued) role is de�ned.
F-Logic enables �ne distinctions in possible meanings of exists: It can select objects on which a
role is de�ned; alternatively, it can select objects on which a role is applicable. We show here only
the �rst meaning. Axiomatization for the de�ned meaning is:
C :: exists( R ) � C[R�!! fg](4)
Note that this axiomatization of exists(R) does not explicitly require the existence of a value
object for R, since R maybe de�ned but its value maybe the empty set. The exact account for the
conventional meaning of exists (R) is given by at-least(1, R) (see 7). An alternative axiomatization
using rules is also presented in [9].
[all] The all operator selects all objects at which the values of a (set-valued) role are restricted by a
given class. In F-Logic's terms, all selects all objects that satisfy a typing restriction:
C
1
:: all( R; C ) � C
1
[R)) (C)](5)
The all operator can be axiomatized without signature F-molecules, as follows:
C
1
:: all( R; C ) � 8C
2
; ( C
1
[R�!! fC
2
g] �! C
2
:: C )(6)
[at-least] The at-least operator imposes cardinality restrictions on the values of the roles:
C
1
:: at-least( 1; R ) � 9C
2
; C
1
[R�!! fC
2
g](7)
C
1
:: at-least( 2; R ) � 9C
2
; C
3
; C
2
6= C
3
^ C
1
[R�!! fC
2
; C
3
g](8)
Hence, assuming the de�ned meaning for exists,
at-least( 1; R ) :: exists(R)(9)
at-least( 2; R ) :: exists(R)(10)
hold in every model of 4, 7, 8.
[and-role] In the method-oriented approach of F-Logic, and(R
1
; . . . ; R
n
) is a method de�ned/applicable
only where all R
i
-s are, and it gets only values common to all R
i
-s. Its axiomatization, using the
de�ned view:
C
1
[and( R
1
; . . . ; R
n
);; fC
2
g] �
n
^
i=1
( C
1
[R
i
;; fC
2
g] )(11)
where ;; stands for one of the arrows!!, �!!. Note that the object constructor and can have a
changing arity, and is used, both as a concept constructor (2) and as a role constructor (11). This
is in line with F-Logic's view of roles (methods) as objects.
13
[inverse]
C
1
[inverse( R );; fC
2
g] � C
2
[R;; fC
1
g](12)
where ;; stands for one of the arrows !!, �!!.
Inheritance of poperties in DLs, that result from the �xed meaning of the operators, also extend to
the F-Logic formulation. For example, since inheritance of signatures is mandatory, we have:
if C
1
:: C
2
then all( R; C
1
) :: all(R; C
2
)
holds in every model of 5, for every R and C
1
; C
2
.
5.2 Replacing the Standard Set-theoretic Semantics by the OO Semantics of F-Logic
In this section we summarize our results that show that when the set-theoretic semantics of DLs is
replaced by the OO semantics of F-Logic, nothing is lost, i.e., logical implication is preserved.
Given an L
P
, a description language with a �nite set P of concept and role forming operators, and
formulae:
c
n
:
= c; r
n
:
= r; c
1
� c
2
; r
1
� r
2
; o 2 c; (o
1
; o
2
) 2 r
while c
n
; r
n
stand for concept and role symbols, respectively; c; c
1
; c
2
; r; r
1
; r
2
stand for concept
and role terms, respectively, and o; o
1
; o
2
stand for object symbols. Two special concept symbols are:
top and bottom. The semantics of L
P
is de�ned, as described in Appendix A, over a domain D, where
concept terms are mapped to subsets of D, role terms are mapped to binary relations over D, and object
symbols are assigned elements of D. The symbols top and bottom are assigned D and ;, respectively.
Formulae are interpreted by interpreting
:
= as set equality, � as set inclusion, and 2 as membership over
D.
In [9] it was argued that a description language L
P
is a syntactic variant for a sorted F-Logic language,
with sorts for concepts, roles, and objects. The syntactic abbreviations are summarized in the following
table:
2 L
P
FL
2 L
FL
P
c
n
:
= c c
n
:
= c
c
1
� c
2
c
1
:: c
2
o 2 c o : c
7
r
n
:
= r 8
ind
8
X; Y; (X [r
n
!! fY g] � X [r!! fY g])
r
1
� r
2
8
ind
X; Y; ( X [r
1
!! fY g] �! X [r
2
!! fY g])
(o
1
; o
2
) 2 r o
1
[r!! fo
2
g]
Note that the table is not a translation from DLs to F-Logic, but just a set of abbreviations. DL terms
are, already, F-Logic terms; the table summarizes syntactic variations and agreed upon abbreviations.
The semantics of L
P
, viewed as an F-Logic language, is de�ned over a partially ordered domain U ,
with a greatest and a least elements, where terms are mapped to elements of U , and the symbols top and
bottom are assigned the greatest and least elements, respectively. The meaning of formulae is directly
obtained from the meaning of their F-Logic variants. Formulae are interpreted by interpreting
:
= and �
between concept terms as equality and the partial ordering, respectively; 2 between an object symbol
and a concept term is interpreted as the membership binary relation over U ;
:
= and � between role terms
7
A simpler, although less intuitive, abbreviation is obtained if an L
P
formula o 2 c is replaced by the L
FL
P
formula o :: c.
8
The subscribed quanti�er \8
ind
" quanti�es over the sort of individuals.
14
are interpreted as methods' equality and implication, respectively; 2 between a pair of object symbols
and a role term is interpreted as a method's value assertion.
An important notion de�ned in [9] was that of a corresponding theory for L
P
, which was de�ned as
an F-Logic theory FL
P
such that for every set of formulae �, and a formula in L
P
:
� j= iff FL
P
; �
FL
j=
FL
(The �rst j= is the description languages' logical implication relation, while the second is F-Logic's. The
FL superscript stands for the F-Logic's notational variant.) A corresponding theory for P = fand, all,
at-least1, and-role g was given. A major result of [9] is that given a corresponding theory FL
P
to L
P
,
F-Logic provides a full account to L
P
, i.e., it correctly simulates logical implication and subsumption
relations, while preserving the direct semantics. In particular, we had the following corrolary:
Corollary 5.1 Let t
1
; t
2
be terms of L
P
, and FL
P
an F-Logic's theory that corresponds to L
P
. Then,
t
1
is subsumbed by t
2
in a terminology � i� FL
P
; �
FL
j= (t
1
� t
2
)
FL
.
Henceforth, we identify L
P
with its abbreviations in F-Logic. That is, a DL formula is always a
shorthand for its F-Logic abbreviation
FL
, as de�ned in the above table. The semantics is F-Logic's.
Note: There is a close relationship between F-Logic and the Omega system of [3,4], as both are classical
logic languages, based on ideas of taxonomy, inheritance, and attribution. The Omega system, being
a description language, has also the built-in description operators and, or, not. In the DFL approach,
these operators, and possibly others as well, may be captured by the description oracle axioms. The
exact correlation between the DFL approach and the Omega system needs further study. 2
5.3 Inferential Account and Extended Expressivity
In [9] we proved the F-Logic correctness of DL subsumption algorithms, and showed that this approach
can account for desired features of DLs, that are problematic in the standard account of DLs.
In [1], a constraints-based approach, for testing coherence of concept descriptions and subsumption
relations between concept descriptions in the language ALb, was introduced. The approach involves
intermediate formalisms, called constraints systems. We showed that the algorithms of this constraints-
based approach can be viewed as operating on descriptions in F-Logic, and that all results are preserved,
with respect to an F-Logic's theory that corresponds to ALb. Moreover, the intermediate formalisms are
subsets of F-Logic, as well.
The normalize-compare approach ([55,42]) is the most popular/standard method for checking sub-
sumption between concept/role descriptions. This is a two step method, where in the normalize step
concept descriptions are transformed into some normal form, and in the compare step, subsumption
is decided by comparing normalized descriptions. In the DFL approach, the normalize step is a pre-
processing step for optimizing or simplifying concept descriptions. The compare step is a specialized
inference algorithm, used by the DL reasoner, for checking the hierarchical relationship between normal-
ized descriptions.
The extended descriptions discussed in [9] include n-ary roles ([61,10]), intensions, high order opera-
tors, collective entities ([23]), and roles as �rst class objects. For example:
1. High order roles and operator forming operators: Cardinality operators like at-least(n, R), can be
\upgraded" by using at-least(n) as a family of concept forming constructors, with the de�nition:
at-least(n)(R)
:
= at-least(n;R):
15
2. Collective entities: The statement \Strikers throw tomatoes" can be written:
(strikers; tomatoes) 2 cumulative(throw); where strikers and tomatoes are not individuals.
3. Roles as �rst class objects: The cardinality of the parent role can be imposed by:
parent � and(at-least(2); at-most(2))
6 Compositional Semantics
Let KB be a hybrid knowledge base as described in Section 2, with a descriptions database D, a de-
scription languages reasoner DL, and a rules reasoner R. The database D is a full DL knowledge base,
as described in Table 3. Note that in F-Logic, D is a de�nite positive logic program, since all concept
descriptions and membership assertions abbreviate atomic formulae (F-molecules) in F-Logic, each role
de�nition is an abbreviation for two rules, and each primitive role introduction is an abbreviation for a
single rule.
Let L
P
be the language of descriptions in D, FL
P
be its corresponding F-Logic's theory, and RULES
the set of rules that R consults. Then, a straightforward non-hybrid approach to the meaning of KB,
can de�ne the models of KB as F-Logic models I such that:
I j= D [RULES [ FL
P
That is, a formula is true in KB if it is logically implied from D [ RULES [ FL
P
, and hence, can be
inferred by F-Logic's sound and complete proof system. While this approach might be satisfactory from
a theorem proving point of view, it is inappropriate from a knowledge representation point of view. The
hybrid knowledge base should provide speci�c services, that �t the mode of operation outlined above.
The two main principles of the hybrid construction are:
1. Modularity: The DL and R reasoners should keep their independent status. The knowledge base
should be able to provide separate services, based on the DL or the R reasoners.
2. Compositional behavior: The knowledge base should be able to compose its separate DL and R
services with, possibly, other reasoning services, to form its compositional behavior. Its semantics
should be composed from the separate semantics of DL and R, which may operate along di�erent
reasoning policies.
Clearly, neither of these principles is kept if the \global" F-Logic theory D[RULES [ FL
P
de�nes the
semantics of KB. Two desirable properties are:
1. Query sensitivity: There are only speci�c forms of queries that the knowledge base should handle,
not unrestriced formulae. Also, the knowledge base is expected to provide answers to queries, not
just a true=false output. Di�erent query behaviors should be re ected in the semantics. For a DFL
KB the expected queries are not-necessarily ground descriptions, and the answers are instantiations
for query variables.
2. Open behavior: The knowledge base should be tolerant to changes in the separate services.
Changes in the R service amounts to addition or deletion of rules. Changes in the DL service
amounts to changes in P , the set of concept/role forming operators.
In this section we de�ne four alternative compositional semanticsH , F , singleF , and OF , that respect
the two main principles of the hybrid construction. All four semantics are sets of syntactic objects, either
16
in DL terms, or in terms of the underlying F-Logic formalism. They are constructed by iteration of the
separate semantics DL and R of the DL and the R reasoners, respectively. DL and R are also sets of
syntactic objects. This way the principles of modularity and Compositionality are kept. The general
structure of the compositional semantics is captured in the following diagram:
DFL = KB semantics
D
. " &
DL = DL semantics j R = R semantics
& j .
DL [R
The general structure of the compositional semantics is as follows:
De�ne: T (KB)
def
= DL [ R
and T
0
(KB) = S
0
{ semantics' dependent initial version.
T
k+1
(KB) = T (T
k
(KB)) k � 0
T
!
(KB) =
1
[
k=0
T
k
(KB)
Then: DFL(KB)
def
= T
!
(KB)
The four semantics di�er in the separate DL and R being used, and in the sort of syntactic objects
being processed. In the H semantics the syntactic objects are ground atoms of the underlying F-Logic
formalism; in the F and the singleF semantics the syntactic objects are ground descriptions; in the OF
semantics the syntactic objects are not necessarily ground descriptions, and also rules of F-Logic. Hence,
H is neither query sensitive nor open, F and singleF are query sensitive but not open, and OF is both
query sensitive and open. The expressivity relations between the four semantics are:
H � F = singleF � OF
with the following reservations:
1. F = singleF holds only when the R reasoner consults a set of de�nite positive rules, without
negation.
2. The OF semantics is de�ned only for an R reasoner that consults a set of de�nite positive rules.
Background concepts in partial orders, lattices, and logic programming are summarized in Appendix
C. Herbrand structures (H-structures) and models (H-models) in F-Logic are introduced at the end of
Appendix B.
6.1 H { A Herbrand Model Basd Semantics
The H semantics is constructed from F-Logic Herbrand models of a gradually increasing database of
descriptions D. The construction starts with D and continues with increasing Herbrand models of D,
constructed separately by the two reasoners. The Herbrand universe is taken over the symbols in D.
17
1. DLH { Semantics of DL: Let S be a set of F-Logic's ground molecules. Then:
DLH(S) = \fH j H is a Herbrand model of D [ S [ FL
P
g
2. RH { Semantics of R: The H semantics assumes that the rules reasoner R is provided with an
intended Herbrand model semantics. That is, for a given D, the R semantics of D is given by a
prefered (intended) Herbrand model of D[RULES. Let S be a set of F-Logic's ground molecules.
Then:
RH(S) = The intended Herbrand model of D [ S [RULES
3. Compositional semantics:
De�ne: TH(S)
def
= DLH(S)[RH(S)
and TH
0
(D) = D=atom, i.e., concept descriptions (formulae) in D.
Then: H(D)
def
= TH
!
(D)
Example 1
P = fallg
D : 1) (a; b) 2 r
2) a 2 all(r; all(r; c))
RULES : a 2 all(r; all(r; all(r; Y ))) � b 2 all(r; Y )
Henceforth, we use the shortened notation all
k
(r; c) which stands for all(r; all(r; . . . ; all(r; c) k times.
i = 0 : TH
0
(D) = D = D
0
i = 1 : DLH(D
0
) = f (1); (2); 3)b 2 all(r; c) g
RH(D
0
) = f (1); (2) g
TH
1
(D) = f (1); (2); (3) g = D
1
i = 2 : DLH(D
1
) = D
1
RH(D
1
) = f (1); (2); (3); 4)a 2 all
3
(r; c) g
TH
2
(D) = f (1); (2); (3); (4) g = D
2
.
.
.
i = 2j : (j � 1)
DLH(D
2j�1
) = f(1)g[ fb 2 all
k
(r; c) j 1 � k � jg[ fa 2 all
k
(r; c) j 2 � k � j + 1g
RH(D
2j�1
) = f(1)g[ fb 2 all
k
(r; c) j 1 � k � jg[ fa 2 all
k
(r; c) j 2 � k � j + 2g
TH
i
(D) = f(1)g[ fb 2 all
k
(r; c) j 1 � k � jg[ fa 2 all
k
(r; c) j 2 � k � j + 2g
i = 2j + 1 : (j � 0)
DLH(D
2j
) = f(1)g[ fb 2 all
k
(r; c) j 1 � k � j + 1g[ fa 2 all
k
(r; c) j 2 � k � j + 2g
RH(D
2j
) = f(1)g[ fb 2 all
k
(r; c) j 1 � k � jg[ fa 2 all
k
(r; c) j 2 � k � j + 2g
TH
i
(D) = f(1)g[ fb 2 all
k
(r; c) j 1 � k � j + 1g[ fa 2 all
k
(r; c) j 2 � k � j + 2g
.
.
.
H(D) =
1
[
i=0
TH
i
(D) = f(1)g [ fb 2 all
k
(r; c) j 1 � kg[ fa 2 all
k
(r; c) j 2 � kg
18
2
Claim 6.1 The sequence TH
0
(D); TH
1
(D); . . . is an ascending chain of Herbrand structures.
Proof: TH
0
(D) � DLH(D
1
) � TH
1
(D) � DLH(D
2
) � TH
2
(D) . . . 2
Claim 6.2 H(D) is a Herbrand model of D and of RULES, but not necessarily of FL
P
.
Proof: In Appendix D. 2
Note that H(D) is not necessarily a Herbrand model of FL
P
, since FL
P
may include wild formulae,
depending on the intended meaning of operators in P .
Evaluation of the H Semantics
TheH semantics is not query sensitive since it concentrates on syntactic objects of the underlying F-Logic
formalism, rather then on descriptions. For example, a reasonable query might be: \�nd all roles R such
that R � r holds in the knowledge base". Since R � r abbreviates an F-Logic's rule, it is not included in
the H semantics. Indeed, one might say that this is a limitation of the underlying F-Logic, that it does
not support built-in hierarchy for roles. While this may well be so, it does not solve the problem, as a
description language may include other formulae, such as c � r, standing for some special relationship
between a concept and a role. We cannot expect the underlying logic to have built-in atomic constructs
for all DL formulae.
The H semantics is not open in two manners:
1. It assumes that the set of objects manipulated by the system is given in D { since the Herbrand
universe is taken over D.
2. It assumes that the two reasoners have all the knowledge they need to consult with, available.
Situations like a growing set of terminological operators, or a growing set of rules, are not coped
with. If the set of rules is augmented, the R reasoner should be rede�ned, implying rede�nition of
H(D).
The semantics F , singleF , OF , introduced in the next three subsections are query sensitive, since
they are given in terms of descriptions. All three share a common semantics for the DL reasoner, that
maps a set of descriptions into a larger set of descriptions. The semantics of the R reasoners in F ,
singleF and OF are given in terms of the underlying F-Logic formalism. They are de�ned, each, by
repeated applications (possibly in�nite) of an operator(s), that depend on the set of rules RULES, and
on the database D. This is a realistic assumption, since it is satis�ed by most conventional semantics of
logic programs. In particular, this characterization is satis�ed by the ground least fixpoint semantics
([21]) and the unfloding semantics ([13]) of de�nite positive logic programs, and by the iterated fixpoint
semantics ([2]) of strati�ed de�nite logic programs with negation.
6.2 F { A Ground Fixpoint Based Semantics of Descriptions
1. The semantics of DL { DLF : DLF (D) = fq j q 2 L
P
; D [ FL
P
j= qg.
Note that DLF (D) abbreviates rules in F-Logic.
19
2. The semantics of R { RF :
RF considers the database D as a set of F-Logic's rules. Its de�nition depends on the syntactic
structure of RULES. If RULES is a definite; positive logic program, then the operator used in
the de�nition of RF is the standard immediate consequences operator, T
D[RULES
9
:
RF (D) =
1
[
i=0
T
D[RULES
" i = T
D[RULES
" !(13)
If RULES is a definite logic program with negation, and D [ RULES can be strati�ed, then
RF (D) can be de�ned via operators (O
D;RULES
)
i
, one for each stratum, using, for example, the
iterated �xpoint approach ([2]). In either case, RF is based on a mapping on F-Logic H-structures.
Note that since the databaseD can increase between successive applications ofRF , each application
uses a di�erent operator. The set RULES is �xed along the iterative process.
3. Compositional semantics:
De�ne: TF (D)
def
= DLF (D) [RF (D)
and TF
0
(D) = D
Then: F (D)
def
= TF
!
(D)
Examples: For Example 1, with RF de�ned as in Equation 13 using the standard immediate conse-
qunces operator, the same iterations are obtained, i.e., TF
i
(D) = TH
i
(D); i � 0.
Example 2
P = fand-role, composeg
D : 1)(a; b) 2 r
2)r � and-role(compose(r; r); r)
RULES : (X; Y ) 2 compose(compose(R;R); compose(R;R)) � (X; Y ) 2 compose(R;R)
This rule can be written as the non-ground description:
compose(R;R) � compose(compose(R;R); compose(R;R))
It cannot be part of the database D since it includes variables.
We assume that RF is de�ned as in Equation 13, using the immediate consequences operator.
i = 0 : TF
0
(D) = D = D
0
i = 1 : DLF (D
0
) = f(1); (2); 3)r � compose(r; r); 4)(a; b) 2 compose(r; r);
5)(a; b) 2 and-role(compose(r; r); r); . . .g
RF (D
0
) = f(1)g
TF
1
(D
0
) = f(1); (2); (3); (4); (5); . . .g = D
1
i = 2 : DLF (D
1
) = D
1
RF (D
1
) = f (1); (4); (5);
6)(a; b) 2 compose(compose(r; r); compose(r; r));
7)(a; b) 2 compose( compose(compose(r; r); compose(r; r));
compose(compose(r; r); compose(r; r))); . . .g
.
.
.
9
Operator powers O " i are de�ned in Appendix C.
20
F (D) = f(1); (2); (3)g[
f(a; b) 2 compose
i
(r; r) j i � 1; where
compose
1
(r; r) = compose(r; r);
compose
i+1
(r; r) = compose(compose
i
(r; r); compose
i
(r; r))g[
f(a; b) 2 and-role . . .g[ fr � and-role . . .g
Note that in the �rst cycle the R reasoner is not active; it waits for the DL reasoner, to untie for it
description (2), based on the meaning of the and-role operator. F (D) does not include descriptions of
the form compose
i
(r; r)� compose
i+1
(r; r) (i � 1), that are logically implied from D[RULES[FL
P
,
since its R reasoner maps only H-structures. This limitation is removed in the OF semantics (see Example
5). The H semantics, for Example 2, is weaker:
H(D) = f(1)g [ f(a; b) 2 compose
i
(r; r) j i � 1g [ f(a; b) 2 and-role . . .g
2
Claim 6.3 The sequence hTF
i
(D)i
i�0
is an ascending chain.
Proof: D = TF
0
(D) � DLF [TF
0
(D)] � TF
1
(D) � DLF [TF
1
(D)] � TF
2
(D) . . . 2
De�nition 6.4 RF (D) is called monotonic if D
1
� D
2
implies RF (D
1
) � RF (D
2
).
Clearly, the monotonicity ofRF (D) depends on the F-Logic's H-structures mapping used in the de�nition
of RF (D). If RF (D) is de�ned as in Equation 13, then RF is monotonic. This is so, since if P
1
� P
2
then T
P
1
(I) � T
P
2
(I) for any H-structure I , implying T
P
1
" ! � T
P
2
" !.
Claim 6.5 If RF (D) is monotonic then TF (D) is also monotonic.
Proof: Let D
1
� D
2
. TF (D
1
) � TF (D
2
); since TF (D
1
) = DLF (D
1
) [ RF (D
1
); and
TF (D
2
) = DLF
P
(D
2
)[RF (D
2
); and we have DLF (D
1
) � DLF (D
2
); and RF (D
1
) � RF (D
2
). 2
The next theorem establishes the relation between the H and F semantics, based on the assumption
that RH(D) = RF (D).
Theorem 6.6 If RF (D) is monotonic: F (D) � H(D).
Proof: In Appendix D. 2
Corollary 6.7 The minimal H-structure of F (D), denoted M [F (D)] includes H(D).
Proof: M [F (D)] � F (D)=atom � H(D).
2
The other direction of Theorem 6.6 is M [F (D)] � H(D). We conjecture that indeed, this is so, at
least for an R reasoner that uses a de�nite positive logic program as its set of RULES. However, this
direction of the inclusion may not hold between corresponding steps in the F and H construction since
in the H construction the set of role formulae in D is �xed, while in the F construction it may grow, by
the DL reasoner. Hence, at individual steps the F construction may be richer.
21
6.3 SingleF { An Iteration Based Semantics of Descriptions
The singleF semantics is a simpli�cation of the F semantics, and is de�ned only for F semantics whose
R reasoner's semantics is an in�nite iteration of an operator O
D;RULES
, as, for example, in the case of
the immediate consequences operator, for de�nite positive logic programs (Equation 13). That is:
RF (D) =
1
[
i=0
O
D;RULES
" i = O
D;RULES
" !
This restriction is necessary since in the singleF semantics the R reasoner applies its operator just a
single step, at each iteration. This way, the singleF semantics avoids the \iteration over iteration"
construction of F . The de�nition of singleF is identical to F , except for the de�nition of RF :
1. DLsglF (D) = DLF (D).
2. RsglF (D) = O
D;RULES
(M(D)).
3. TsglF (D) = DLsglF (D)[RsglF (D)
TsglF
0
(D) = D
singleF (D) = TsglF
!
(D).
Example 3 The input for this example is the same as in Example 2, but the iterations obtain one
description per iteration, not in�nity.
P = fand-role, composeg
D : 1)(a; b) 2 r
2)r � and-role(compose(r; r); r)
RULES : (X; Y ) 2 compose(compose(R;R); compose(R;R)) � (X; Y ) 2 compose(R;R)
i = 0 : TsglF
0
(D) = D = D
0
i = 1 : TsglF
1
(D
0
) = f(1); (2); 3)r � compose(r; r); 4)(a; b) 2 compose(r; r);
5)(a; b) 2 and-role(compose(r; r); r); . . .g = D
1
i = 2 : TsglF
2
(D
1
) = f(1); (2); (3); (4); (5); 6)(a; b) 2 compose
2
(r; r); . . .g = D
2
i = 3 : TsglF
3
(D
2
) = f(1); (2); (3); (4); (5); (6); 7)(a; b) 2 compose
3
(r; r); . . .g = D
3
.
.
.
singleF (D) = F (D).
2
The following theorems establish the relationships between the F and the singleF semantics. The
theorems hold for O
D;RULES
being the standard immediate consequences operator T
P
of de�nite positive
logic programs, since this operator is monotonic and continuos. Hence, it satis�es the assumptions of the
theorems.
First we note some properties of the singleF semantics, similarly to the properties of the F semantics.
Claim 6.8 The sequence hTsglF
i
(D)i
i�0
is an ascending chain.
Proof: D = TsglF
0
(D) � DLsglF [TsglF
0
(D)] � TsglF
1
(D) � DLsglF [TsglF
1
(D)] � FsglT
2
(D) . . .
2
22
Claim 6.9 If O
D;RULES
is monotonic, then RsglF and TsglF are also monotonic.
Proof: As in the F semantics.
2
The following theorem shows that if the operator on which the RF semantics is based behaves
\reasonably", then the singleF semantics is included in the F semantics.
Theorem 6.10 If the O
D;RULES
is monotonic, and its application to M(D) is included in its in�nite
iteration, i.e., O
D;RULES
(M(D)) � O
D;RULES
" !, then: F (D) � singleF (D).
Proof: In Appendix D. 2
The following theorem claims that if the operator on which the RF semantics is based behaves
\continuously" on chains of description sets, then the singleF semantics includes the F semantics. All-
together, the two theorems state the necessary and su�cient conditions for equality between the two
semantics.
Theorem 6.11 If the O
D;RULES
is monotonic, and for all ascending chains of sets of descriptions D
i
,
where D =
1
[
i=0
D
i
; O
D;RULES
[M(D)] �
1
[
i=0
O
D
i
;RULES
[M(D
i
)], then: F (D) � singleF (D).
Proof: In Appendix D. 2
6.4 OF { A Non-Ground, Fixpoint Based Semantics of Descriptions, with an Open
RULES Set
The semantical approaches described so far assume that a knowledge base is provided with a DL and an
R reasoners, with �xed behavior (semantics). This assumption is not realistic for R, since the rules set is
the typical source of knowledge of expert systems, which can be incomplete and faulty. The �xed rules
set assumption in a changing envorinment presents two major problems:
1. The semantics of R with the rules set RULES
1
[RULES
2
is independent from the semantics of R
with rules sets RULES
1
and RULES
2
. A natural expectation is that R
RULES
1
[RULES2
is derived
from R
RULES
1
and from R
RULES
2
.
2. The R reasoner cannot infer descriptions that are not ground atoms, such as r
1
� r
2
. For example,
assume that the rules set includes the two rules:
(X; Y ) 2 r
2
� p:
p � (X; Y ) 2 r
1
:
If R includes the resolvent of the two rules, i.e., (X; Y ) 2 r
2
� (X; Y ) 2 r
1
; then since this
derived rule is also the description r
1
� r
2
, it can be added to the descriptions database D, and
used by the DL reasoner in the next round.
The OF semantics augments the F semantics in the direction of an open set of rules. It is based on
the s-semantics approach [13], where the semantics of a logic program is given by a set of, not necessarily
ground, rules, that are resolvents of the given program. In the OF approach, ROF is a set of rules,
that contribute both to the descriptions database D, and to the rules' set RULES. Hence, between
successive applications of the TOF operator, both, the database of descriptions and the set of rules can
23
change (grow). The R reasoner becomes truely modular and open, and the DL and R reasoners become
homogenous in the type of their meanings. The OF semantics applies only to rules' sets with positive
de�nite rules alone.
In the OF semantics the DL and the R reasoners manipulate, at each moment, the current set of
rules, and the current set of descriptions. That is, if at a certain point of time, the R reasoner consults
RULES, and the descriptions database is D, then DL and R operate on DR = D[RULES. DL yields
new descriptions, and R yields new descriptions and rules. The results of DL and R are combined to
generate the new set of descriptions and rules. OF di�ers from F and from singleF in the semantics of
the two reasoners.
1. The semantics of DL: The DL reasoner applies the regular DLF operator to the descriptions in
DR. In order to extract the set of all descriptions from DR we de�ne a non-ground version of L
P
:
Let V ar = V ar
c
[V ar
r
[V ar
o
be a set of variable symbols, whose symbols are appropriately sorted.
Let NAME be the set of (sorted) symbol names in L
P
, and assume NAME \ V ar = ;. L
V ar
P
is
the DL with the set of symbol names NAME [ V ar and set of operators P . Clearly, L
P
� L
V ar
P
.
A substitution is a set of bindings, where a binding is a pair (v; t), where v is a variable and t
is an L
P
term of the same sort as v. Di�erent bindings in a substitution have di�erent variables.
For t 2 L
V ar
P
and a substitution �, t� is t with all variables from � replaced by their corresponding
terms.
The descriptions in DR are selected in two steps: First, an operator D selects all rules that can be
abbreviated by non-ground descriptions, i.e., be members of L
V ar
P
; then they are instantiated into
ground descriptions. That is, for a set S of rules:
D(S) = S \ L
V ar
P
,
kD(S)k = ft� j t 2 D(S); � a substitution; t� 2 L
P
g.
Then, DLOF (DR) = DLF (kD(DR)k)
2. The semantics of R: The R reasoner computes all resolvents of DR. First, we de�ne a sequence of
sets of descriptions and rules, using the unfolding operator ([13], see also Appendix C ):
DR
0
= DR
DR
i
= unf
DR
i�1
(DR); i � 1
Then, ROF (DR) =
1
[
i=0
DR
i
3. The compositional OF semantics:
TOF (DR) = DLOF (DR)[ ROF (DR)
OF (D) =
1
[
i=0
TOF
i
(D [ RULES)
Examples: In the following two examples, role relations that are obtained by the R reasoner, allow the
DL reasoner to obtain new descriptions, that could not be obtained otherwise.
Example 4
24
P : fatleast1g
D : 1)c � atleast1(r
1
; d)
RULES : 2)(X; Y ) 2 r
2
� p:
3)p � (X; Y ) 2 r
1
:
Denote: DR
0
= D [RULES.
i = 0 : TOF
0
(DR
0
) = DR
0
i = 1 : DLOF (DR
0
) = D
ROF (DR
0
) = DR
0
[ f 4)r
1
� r
2
g
Since: DR
0
0
= DR
0
DR
0
1
= unf
DR
0
0
(DR
0
) = f(1); (4)g
DR
0
2
= unf
DR
0
1
(DR
0
) = f(1)g
TOF
1
(DR
0
) = DR
0
[ f(4)g = DR
1
i = 2 DLOF (DR
1
) = DLF (f(1); (4)g) =
= f (1); (4); 5)c � atleast1(r
2
; d); 6)atleast1(r
1
; c) � atleast1(r
2
; c);
7)atleast1(r
1
; d) � atleast1(r
2
; d)g
ROF (DR
1
) = DR
1
Since: DR
1
0
= DR
1
DR
1
1
= unf
DR
1
0
(DR
1
) = f(1); (4)g
DR
1
2
= unf
DR
1
1
(DR
1
) = f(1)g
TOF
2
(DR
0
) = DR
0
[ f(4); (5); (6); (7)g= DR
2
i = 3 DLOF (DR
2
) = f(1); (4); (5); (6); (7)g
ROF (DR
2
) = DR
2
TOF
3
(DR
0
) = DR
2
= OF (D)
2
Example 5
P = fand-role, compose, atleast1g
D : 1)r � and-role(compose(r; r); r)
2)a 2 atleast1(r; c)
RULES : 3)(X; Y ) 2 compose(compose(R;R); compose(R;R)) � (X; Y ) 2 compose(R;R)
Denote: DR
0
= D [RULES.
i = 0 : TOF
0
(DR
0
) = DR
0
i = 1 : DLOF (DR
0
) = f(1); (2); 4)r � compose(r; r); 5)a 2 atleast1(compose(r; r); c); . . .g
ROF (DR
0
) = DR
0
TOF
1
(DR
0
) = DR
0
[ f(4); (5); . . .g = DR
1
i = 2 DLOF (DR
1
) = f(1); (2); (4); (5); . . .g
ROF (DR
1
) = DR
1
[ f (X; Y ) 2 compose
i
(r; r) � (X; Y ) 2 r j i � 1g =
DR
1
[ f r � compose
i
(r; r) j i � 1g
TOF
2
(DR
0
) = DR
1
[ f r � compose
i
(r; r) j i � 1g = DR
2
i = 3 DLOF (DR
2
) = f(1); (2); (4)g [fr � compose
i
(r; r) j i � 1g [ . . .
[fa 2 atleast1(compose
i
(r; r); c) j i � 1g [ . . .
ROF (DR
2
) = DR
2
TOF
3
(DR
0
) = DR
2
[ fa 2 atleast1(compose
i
(r; r); c) j i � 1g = OF (D)
25
This example demonstrates the extra power of the OF semantics over the F semantics: The descriptions
in fr � compose
i
(r; r) j i � 1g and in fa 2 atleast1(compose
i
(r; r); c) j i � 1g could not be obtained
in Example 2. 2
Proposition 6.12 The operator TOF is monotonic.
Proof: Straightforward result, from the monotonicity of DLOF and ROF . 2
Proposition 6.13 TOF (S) � S.
Proof: TOF (S) � ROF (S) =
1
[
i=0
S
i
� S
0
= S. 2
The following theorem compares the OF semantics with the F semantics, when the R reasoner in
the latter consults a de�nite positive logic program as the set RULES, and is de�ned with the standard
immediate consequences operator T
D[RULES
, as in Equation 13. The theorem shows that in this case,
the OF semantics is more powerful than the F semantics.
Theorem 6.14 If RF is de�ned as in Equation 13, then the OF semantics is more powerful than the
F semantics. That is: F (D) � kD[OF (D)]k.
Proof: In Appendix D. 2
The opposite direction to Theorem 6.14 does not hold. Example 4 is a counter example:
� OF (D) = DR
2
= DR
0
[ f(4); (5); (6); (7)g.
� In the F semantics, we get for this example:
TF
0
(D) = D
DLF (D) = D
RF (D) = T
D[RULES
" ! = f(1)g
TF
1
(D) = D = F (D)
� Hence: F (D) = f(1)g � f(1); (4); (5); (6); (7)g= kD[OF (D)]k.
The OF semantics is still not, truely, open, in the sense that the semantics of R with a rules' set
RULES
1
[ RULES
2
is obtained from its semantics with separate rules' sets RULES
1
and RULES
2
.
This openness feature can be obtained by further generalizing ROF with the assumption that the rules'
set is incomplete, as it is done in the -open semantics ([13,14]). Another possible variation of the
OF semantics is singleOF , in analogy to the singleF semantics. The de�nition of, both, -OF and
singleOF is straightforward.
7 Inference
The compositional semantics suggests bottom-up inferencing, where a \by-product" of the inference
process, is the derivation of mutiple conclusions, beyond the requested goal. For the DL reasoner, the
Normalize-Compare methods and the assertional reasoning of [57] have this characteristic, while the
26
constraints-based approach doesn't. For the R reasoner, bottom-up methods depend on the form of the
rules' set, and on the selected semantics. In any case, we do not expect that a bottom-up evaluation
procedure will compute the whole compositional semantics, as it will, in most cases, be in�nite. For
example, if and is one of the description operators, then the semantics of the DL reasoner is always
in�nite, due to description tautologies.
For de�nite positive logic programs, many bottom-up methods exist, both for the F and the OF
semantics. In particular, the magic-sets approach ([62]) can be useful, as it provides a kind of goal
directed bottom-up evaluation, i.e., a focused form of bottom-up evaluation.
For a rules set with negation, bottom-up evaluation is close to computation of extensions in Reiter's
default logic ([54]). The relationship between the compositional semantics in this case, to default logic in
general, and to non-monotonic reasoning in DLs in particular ([6,7,53]), is a subject for future research.
Query-Answering in a DFL Knowledge Base
L
V ar
P
can serve as a query language for the overall integrated KB and for the DL reasoner, as an inde-
pendent component. For the R reasoner as an independent component, L
V ar
P
=atom, i.e., the descriptions
that are atoms in F-Logic, can be taken as its query language. The DFL KB can provide private query-
answering services to the two reasoners, based on their specialized inference machineries. The private
services should be consistent with the hybrid service, i.e., if for a query q a reasoner gives an answer �
(that is di�erent from failure or unknown), the overall DFL KB should also give the same answer.
8 Conclusion
In this paper we have introduced the DFL hybrid framework that integrates rules and descriptions,
under a compositional policy that respects the modularity of its components, and is open and sensitive
to query-answering requirements. The hybrid construction is made possible by using F-Logic as an
underlying formalism, of which both rules and descriptions are subsets. The four combined semantics
presented in the paper demonstrate di�erent approaches. The H semantics is de�ned in terms of the
underlying formalism, while the other three are de�ned in terms of the expected behavior of the hybrid
KB. Indeed the H semantics is the weakest among the four. The OF semantics uses a powerful seman-
tics for a syntactically restricted rules component, which activates further reasoning in the descriptions
component. Hence, it is the most powerful.
We think the the DFL approach might have also a more general implication about the construc-
tion of knowledge bases: Small specialized components can be integrated by underlying formalisms, that
uniformly generalize their essential properties. In our treatment, F-Logic, that embeds just the most
essential notions of taxonomy, inheritance, and attribution, and comprise a natural part of a general
purpose formalism (HiLog, in the case of F-Logic), was used to integrate a rules and a descriptions com-
ponents. The components can preserve their independent status, and be manipulated by special purpose
algorithms, as long as the principles of compositionality, modularity, and openness are respected.
Implementation:
It seems tempting to start an implementation by taking an o�-the-shelf DL system, e.g., CLASSIC or
BACK, and an o�-the-shelf F-Logic's system, and to workout an integration. However, a hybrid Rules-
DLs system may not be that straightforward, since each system keeps its own database of descriptions
D in its own specialized format.
Future work:
F-Logic may be augmented with a built-in taxonomic relation between roles, so that roles' formulae of the
27
form r
1
� r
2
will be \�rst class citizens" of the language. Another direction involves the DFL approach
where the R reasoner consults rules with negation, and the investigation of its relationship to existing
non-monotonic extensions of DLs. Still in that direction, it should be noted that F-Logic itself has a
non-monotonic inheritance mechanism built-in, for de�nite positive sets of rules. The inter-relationships
between this mechanism to non-monotonic extensions of DLs is also a subject for future research. The
study of bottom-up evaluation techniques for the R reasoner is essntial for the development of a DFL
application.
Acknowledgements
I am grateful to Veronique Royer and Michael Kifer, who provided detailed comments on an
earlier draft of this paper. I would like to thank also Mike Codish for introducing me to the
non-ground s-semantics approach, and for endless fruitful discussions.
References
[1] M. S.-S. and G. Smolka. Attributive concept descriptions with complements. J. of Arti�cial Intelli-
gence, 48(1):1{26, 1991.
[2] K. Apt, H. Blair, and A. Walker. Towards a theory of declarative knowledge. In J. Minker, editor,
Foundations of Deductive Databases and Logic Programming, pages 89{148. Morgan Kaufmann,
1988.
[3] G. Attardi and M. Simi. Semantics of inheritance and attributions in the description system omega.
Technical Report AI Memo 642, MIT, 1981.
[4] G. Attardi and M. Simi. A description-oriented logic for building knowledge bases. Proceedings of
IEEE, 74(10):1335{1344, 1986.
[5] F. Baader. Augmenting concept languages by transitive closure of roles: An alternative to termino-
logical cycles. In IJCAI-91, 1991.
[6] F. Baader and B. Hollunder. Embedding defaults into terminological knowledge representation
formalisms. In KR-92, pages 306{317, 1992.
[7] F. Baader and B. Hollunder. How to prefer more speci�c defaults in terminological default logic. In
IJCAI-93, pages 669{674, 1993.
[8] F. Baader, B. Hollunder, B. Nebel, H. Pro�tlich, and E. Franconi. An empirical analysis of opti-
mization techniques for terminological representation systems. In KR-92, pages 270{281, 1992.
[9] M. Balaban. The f-logic approach for description languages. Technical Report FC 93-02, Department
of Mathematics and Computer Science, Ben-Gurion University, Beer Sheva, Israel, 1993. To appear
in Annals of Mathematics and Arti�cial Intelligence.
[10] S. Bergamaschi, S. Lodi, and C. Sartori. Representational extensions of dls. In Working notes,
AAAI Fall Symposium on Issues in Description Logics, pages 11{13, 1992.
[11] A. Borgida. Towards the systematic development of description logic reasoners: Clasp reconstructed.
In KR-92, pages 259{269, 1992.
28
[12] A. Borgida, R. Brachman, D. McGuinness, and L. Resnick. Classic: A structural data model for
objects. In ACM-SIGMOD-89, Portland, OR, 1989.
[13] A. Bossi, M. Gabbrielli, G. Levi, and M. Martelli. The s-semantics approach: Theory and applica-
tions. J. of Logic Programming, 12, 1993.
[14] A. Bossi, M. Gabbrielli, G. Levi, and M. Meo. Contributions to the semantics of open logic programs.
In International Conference on Fifth Generation Computer Systems, pages 570{580, 1994.
[15] R. Brachman and H. Levesque. Competence in knowledge representation. In AAAI-82, pages 189{
192, Pittsburgh, PA, 1982.
[16] R. Brachman and H. Levesque. The tractability of subsumption in frame-based description lan-
guages. In AAAI-84, pages 34{37, Austin, Texas, 1984.
[17] R. Brachman and J. Schmolze. An overview of the kl-one knowledge representation system. Cognitive
Science, 9:171{216, 1985.
[18] W. Chen, M. Kifer, and D. Warren. Hilog: A foundation for higher-order logic programming. J. of
Logic Programming, 15(3):187{230, February 1993.
[19] F. Donini, M. Lenzerini, D. Nardi, A. Schaerf, and W. Nutt. Adding epistemic operators to concept
languages. In KR-92, pages 342{353, 1992.
[20] J. Doyle and R. Patil. Two theses of knowledge representation: Language restrictions, taxonomic
classi�cation, and the utility of representation services. J. of Arti�cial Intelligence, 48(3):261{297,
1991.
[21] M. Emden and R. Kowalski. The semantics of predicate logic as a programming language. J. of the
ACM, 23(4):733{742, 1976.
[22] M. Falashi, G. Levi, M. Martelli, and C. Palamidessi. Declarative modeling of the operational
behavior of logic languages. Theoretical Computer Science, 69(3):289{318, 1989.
[23] E. Franconi. Collective entities and relations in concept languages. In Working notes, AAAI Fall
Symposium on Issues in Description Logics, pages 31{35, 1992.
[24] M. Gehrke. Particles of the part whole relation. In Working notes, AAAI Fall Symposium on Issues
in Description Logics, pages 36{38, 1992.
[25] P. Hanschke. How to bene�t from terminological logics. In Working notes, AAAI Fall Symposium
on Issues in Description Logics, pages 45{48, 1992.
[26] P. Hanschke and . Hinkelmann. Combining terminological and rule-based reasoning for abstraction
processes. In German Conference on AI-92, Springer LNCS 671, pages 0{0, 1992.
[27] P. Hayes. The logic of frames. In D. Metzing, editor, Frame Conceptions and Text Understanding,
pages 46{61, Berlin, 1979. Walter de Gruyter and Co.
[28] B. Hollunder, W. Nutt, and M. Schmidt-Schau�. Subsumption algorithms for concept description
languages. In ECAI-90, pages 348{353, 1990.
29
[29] T. Hoppe, C. Kindermann, J. Quantz, A. Schmiedel, and M. Fischer. Back v5: Tutotial and manual.
Technical Report KIT { report 100, Technische Universitat Berlin, March 1993.
[30] M. Kifer and G. Lausen. F-logic: A higher-order language for reasoning about objects, inheritance,
and scheme. In SIGMOD-89, 1989.
[31] M. Kifer, G. Lausen, and J. Wu. Logical foundations of object-oriented and frame-based languages.
Technical Report #93/06, Dept. of Computer Sciencee, SUNY at Stony Brook, April 1993. To
appear in JACM.
[32] H. Levesque and R. Brachman. A fundamental tradeo� in knowledge representation and reasoning.
In R. Brachman and H. Levesque, editors, Readings in Knowledge Representation, pages 41{70,
Calif., 1985. Morgan Kaufman Publishers Inc.
[33] H. Levesque and R. Brachman. Expressiveness and tractability in knowledge representation and
reasoning. Computational Intelligence, 3:78{93, 1987.
[34] K. Luck, B. Nebel, C. Peltason, and A. Schmiesel. The back system. Technical Report KIT Report
29, Department of Computer Science, Technische Universit�at Berlin, Berlin, FRG, 1985.
[35] K. Luck, B. Nebel, C. Peltason, and A. Schmiesel. The anatomy of the back system. Technical
Report KIT Report 41, Department of Computer Science, Technische Universit�at Berlin, Berlin,
FRG, 1987.
[36] R. MacGregor. The evolving technology of classi�cation-based knowledge representation systems. In
J. Sowa, editor, Principles of Semantic Networks: Explorations in the Representation of Knowledge,
pages 385{400. Morgan Kaufmann, 1991.
[37] R. MacGregor. Inside the loom description classi�er. SIGART Bulletin, 2(3):88{92, 1991.
[38] R. MacGregor. What's needed to make a description logic a good kr citizen. In Working notes,
AAAI Fall Symposium on Issues in Description Logics, pages 53{55, 1992.
[39] R. MacGregor, D. McGuinness, E. Mays, and T. Russ, editors. Working notes, AAAI Fall Sympo-
sium on Issues in Description Logics. AAAI, 1992.
[40] A. Napoli. Subsumption and classi�cation-based reasoning in object-based representations. In
ECAI-92S, pages 425{429, 1992.
[41] B. Nebel. Computational complexity of terminological reasoning in back. J. of Arti�cial Intelligence,
34:371{383, 1988.
[42] B. Nebel. Reasoning and Revision in Hybrid Representation Systems. Dissertation, University of
Saarlands, Saarbr�ucken, 1989.
[43] B. Nebel. Terminological reasoning is inherently intractable. J. of Arti�cial Intelligence, 43:235{249,
1990.
[44] B. Nebel. Terminological cycles: Semantics and computational properties. In J. Sowa, editor,
Principles of Semantic Networks: Explorations in the Representation of Knowledge, pages 331{361.
Morgan Kaufmann, 1991.
30
[45] H. Ohlbach and F. Baader. A multi-dimensional terminological knowledge representation language.
In IJCAI-93, pages 690{695, 1993.
[46] L. Padgham and B. Nebel. Combining classi�cation and nonmonotonic inheritance reasoning: A
forst step. In Working notes, AAAI Fall Symposium on Issues in Description Logics, pages 64{71,
1992.
[47] P. Patel-Schneider. Small can be beautiful in knowledge representation. In Proceedings of the 1983
KL-ONE Workshop, Denver, Colorado, 1984.
[48] P. Patel-Schneider. Undecidability of subsumption in nikl. J. of Arti�cial Intelligence, 39:263{272,
1989.
[49] P. Patel-Schneider. Defaults and descriptions. In Working notes, AAAI Fall Symposium on Issues
in Description Logics, pages 74{75, 1992.
[50] P. Patel-Schneider and B. Swartout. Description logic speci�cation { from the krss e�ort. Technical
report, AT&T Bell Labs, June 1993.
[51] A. B. Pfahringer. The logical way to build a dl-bsed kr system. In Working notes, AAAI Fall
Symposium on Issues in Description Logics, pages 76{77, 1992.
[52] J. Quantz. A step towards second order. In Working notes, AAAI Fall Symposium on Issues in
Description Logics, pages 78{82, 1992.
[53] J. Quantz and V. Royer. A preference semanics for defaults in terminological logics. In KR-92,
pages 294{305, 1992.
[54] R. Reiter. A logic for default reasoning. J. of Arti�cial Intelligence, 13(1{2):81{132, 1980.
[55] L. Resnick, A. Borgida, R. Brachman, D. McGuinness, and P. Patel-Schneider. Classic description
and reference manual for common lisp implementation. Technical Report Version 1.02, AT&T Bell
Labs, 1990.
[56] V. Royer and J. Quantz. Deriving inference rules for terminological logics. In D. Pearce and
G. Wagner, editors, Logics in AI, JELIA'92, pages 84{105, Berlin: Springer, LNAI 633, 1992.
[57] V. Royer and J. Quantz. On intuitionistic query answering in description bases. In CADE, 1994.
[58] K. Schild. A correspondence theory for terminological logics: Preliminary report. In IJCAI-91,
pages 466{471, 1991.
[59] M. Schmidt-Schau�. Subsumption in kl-one is undecidable. In Proceedings, Conference on Principles
of Knowledge Representation and Reasoning, pages 421{431, Toronto, Ontario, Canada, 1989.
[60] A. Schmiedel. For a more expressive query language. In Working notes, AAAI Fall Symposium on
Issues in Description Logics, pages 98{102, 1992.
[61] J. Schmolze. Terminological knowledge representation systems supporting n-ary terms. In Confer-
ence on Principles of Knowledge Representation and Reasoning, pages 432{443, Toronto, Ontario,
Canada, 1989.
[62] J. Ullman. Principles of Database and Knowledge-base Systems. Computer Science Press, 1989.
31
[63] W. Woods. Understanding subsumption and taxonomy: A framework for progress. In J. Sowa,
editor, Principles of Semantic Networks: Explorations in the Representation of Knowledge, pages
45{94. Morgan Kaufmann, 1991.
[64] W. Woods and J. Schmolze. The kl-one family. Computers and Mathematics with Applications,
Special Issue on Semantic Networks in Arti�cial Intelligence, 1992.
A Formal De�nition of Description Languages
Recall that a terminology is a set of de�nitions of the form
defined-concept=role-symbol
:
= concept=role-description
The formal de�nition of DLs distinguishes the concept/role symbols that are de�ned (appear at the
left side of a de�nition in the terminology), from those that are not. The de�ned symbols are called
concept/role name symbols, and the rest are primitive concept/role symbols. The concept/role symbols
consist of all primitive and name concept/role symbols. The formulae of DLs are of three kinds:
1. De�nitions, e.g., a parent is a person with at least one child:
parent
:
= and(person; at-least(1; child))
2. Primitive introductions, e.g., a person is a two-legged mammal:
person � and(mammal; two-legged))
3. Individual assertions, e.g., John is Mary's child:
(Mary; John) 2 child
As an example for a typical DL we adopt the DL presented in[56], but we let the set of concept/role
forming operators vary.
Syntax:
Symbols of the language: Primitive concept symbols (c
p
), concept name symbols (c
n
), primitive role
symbols (r
p
), role name symbols (r
n
), object symbols (o), two special concept symbols, top and bottom,
and a �nite set P of concept and role forming operators.
Terms: Terms are either concept terms, or role terms. Concept/role terms are all concept/role symbols,
and all syntactically legal applications of a concept/role forming operator to terms, respectively. A
concept term of any kind is denoted c, and a role term of any kind is denoted r.
Formulae
10
: c
n
:
= c; r
n
:
= r; c
1
� c
2
; r
1
� r
2
; o 2 c; ( o
1
; o
2
) 2 r. The primitive
introductions (formulae with � allowed in the terminology component are, usually, restricted to primitive
symbols alone (left side must be a primitive symbol).
Description languages with this set of formulae di�er from each other just in the sets of allowed
operators. Hence, we denote a typical DL with operators set P by L
P
.
Semantics:
10
Di�erent notations have been used in the DLs' literature. Primitive de�nitions have been denoted also using v or :< ;
membership have been denoted also using 2 or :: ; ) was also used for denoting subsumption. The above formulation
follows the notation in [56].
32
Meaning of formulae is given by a set theoretic semantics. An interpretation I is a pair (D, �), of a
domain D and an interpretation function �, such that concept symbols are assigned subsets of D, role
symbols are assigned binary relations over D
11
, object symbols are assigned elements of D, �(top) is
D, and �(bottom) is ; (the empty set). The interpretation function � is augmented to all concept/role
terms by building into it a �xed meaning for each operator in P. For example, for P = f and, all, some,
and-role, inverse g, the meaning of concept terms is de�ned as follows:
12
�( and( c
1
, c
2
) ) = �(c
1
) \ �(c
2
)
�( all( r, c ) ) = f d 2 D=�(r)(d) � �(c) g
�( some( r, c ) ) = f d 2 D=�(r)(d)\ �(c) 6= ; g
�( and-role( r
1
, r
2
) ) = �(r
1
) \�(r
2
)
�( inverse( r ) ) = f (d; e) 2 D �D=(e; d) 2 �(r) g
Satisfaction of formulae in an interpretation is de�ned by interpreting
:
= as set equality, � as set inclusion,
and 2 as membership over D. An interpretation is amodel for a set of formulae if it satis�es all formulae.
A formula is logically implied from a terminology T, i.e., T j= , if it is satis�ed in every model of the
terminology.
A concept term t is coherent with respect to a terminology T, if there exists a model ( D, � ) of
T, such that �(t) 6= �. The main relationship between terms is the subsumption relation: Term t
1
is subsumed by term t
2
( t
1
v t
2
) in a terminology T, if and only if in every model ( D, � ) of T,
�(t
1
) � �(t
2
). Equivalence of terms is de�ned as two way subsumption. The central role that the
subsumption relationship between concept terms plays in the management of DL knwoledge bases was
already discussed above.
Proposition A.1 t
1
v t
2
in T, i� T j= t
1
� t
2
.
Proof: Immediate from de�nition of subsumption, and semantics of �. 2
B F-Logic
B.1 Syntax { Examples
Here are some examples, taken from [31] (the syntax is somewhat relaxed and simpli�ed):
1. faculty[ boss ) (faculty, manager);
age ) midaged;
highestDegree ) degree;
papers )) article;
highestDegree �! phd;
avgSalary ! 50000]
This statement declares typing information (i.e., signatures) for the attribute-features boss, age,
and highestDegree of faculty, and for the attribute-role papers of faculty. Also, the value of the
inheritable attribute-feature highestDegree at faculty is speci�ed as phd, and the value of the non-
inheritable attribute-feature avgSalary at faculty is speci�ed as 50000.
11
In [16,44], role symbols are assigned total functions from D to P (D). This interpretation of role symbols is somewhat
closer to F-Logic's view of methods.
12
We view relations as set-valued functions, whenever it simpli�es the presentation. In the de�nitions of the meaning of
the operators, we let, for a role symbol r and a domain element d, �(r)(d) denote the set of all domain elements related to
d via �(r), i.e., the set f e=(d; e) 2 �(r) g.
33
2. Car : dieselCars(Y ear) � Car : car[ engineType ! \diesel";
makeYear ! Y ear ]
This statement de�nes a family of classes, parameterized by Y ear. Each class, e.g., dieselCars(1900)
contains all diesel cars made in 1900.
3. Polymorphic typing:
list(T )[ �rst ) T;
rest ) list(T );
length ) int;
append @ list(T ) ) list(T ) ]
4. Knowledge base browsing:
interestingAttributes(X)[ attributes !! L] � X : faculty[ L ! Z : person ]
interestingAttributes(X)[ attributes !! L] � X : faculty[ L !! Z : person ]
These rules de�ne, for every member, o, of the faculty object, a new object, interestingAttributes(o),
with a set-valued attribute, attributes, whose value at that object is the set of all attributes of o
that have a person value.
5. Concepts' similarity via analogy, as in \A Pig-Like-Person is similar to a Pig by his/her nose, legs,
and smell" (an example borrowed from [27]:
mary[ smell ! P ] � like(mary; pig; [nose; legsform; smell]) ^ pig[smell! P ].
This rule states that if mary is similar to a pig by her nose, legsform, and smell, and if pig's smell
is some value P , then mary's smell is also P (we use PROLOG's lists' notation). This rule can be
generalized into any like similarity, as follows:
X [ Attr ! P ] � like(X; Y; PropList) ^ Y [Attr ! P ] ^ member(Attr; PropList).
6. Methods' dependency:
X [heightClass ! tall] � X : person[height ! H ] ^ H � 1:8m
The following subsection summarizes the semantics of F-Logic. It is not essential for the rest of the
paper.
B.2 Semantics
Methods are rei�ed by objects of the domain in a semantic structure. The rei�cation is accomplished by
associating, with each object, a feature (or actually, in�nity of features, one for each arity), a role (again
in�nity), an inheritable feature (in�nity), an inheritable role (in�nity), a type for the feature (in�nity),
and a type for the role (in�nity). We can think about an object d of U as an association:
( d,
array-of-features, array-of-roles, array-of-inheritable-features, array-of-inheritable-roles, array-of-feature-
types, array-of-role-types )
Features, roles, and their types are always referenced indirectly, via their object-names in U , and the
speci�ed arity. This is the \secret" behind the high-logization of F-Logic: Features, roles and types are
rei�ed by their object-names, and quanti�cation over them is carried just over their object-names. The
association is given by six functions, I
!
, I
!!
, I
�!
, I
�!!
, I
)
, and I
))
, that assign to an object d the six
mentioned above arrays of features, roles, inheritable-features, inheritable-roles, types-of-features, and
34
types-of-roles, respectively. (I
(k)
!
denotes the k+1 element of I
!
, for k�0; the superscript corresponds to
the number of additional arguments that the feature/role takes, besides d.)
A semantic structure for an F-Logic language is a tuple I = hU;�
U
;2
U
; I
F
, I
!
; I
!!
, I
�!
; I
�!!
,
I
)
; I
))
i, where (U;�
U
), and 2
U
are the partially ordered domain, and the membership relation, as
described in the previous section. I
F
is the interpretation mapping for object constructors, a standard
function mapping. The other six mappings are the associations of domain objects with features, roles,
and types, as explained above.
Is-a F-molecules are assertions about subset relationships (�
U
) and membership relationships (2
U
)
between objects denoted by id-terms in the molecule.
Data F-molecules are assertions about the value of a feature or a role at a given object. In a data
F-molecule with a non-inheritable-feature:
o[f@arg
1
; . . . ; arg
n
! val];
o; f; arg
1
; . . . ; arg
n
; val, are id-terms. In a given semantic structure and variable assignment I, the id-
terms o; arg
1
; . . . ; arg
n
, val, are mapped to objects of the partially ordered domain ( U , �
U
). The id-term
f is mapped to the non-inheritable feature with n arguments, associated with the object to which the
symbol f is mapped, i.e., to I
(n)
!
( f
I
). The term is true in I if I
(n)
!
(f
I
) is de�ned in ( o
I
; arg
I
1
; . . . ; arg
I
n
) and equals val
I
. For example, I j= mary [ husband-of ! fred ], means that the non-inheritable
feature attribute (1-ary method) associated with husband-of
I
has the value fred
I
at mary
I
.
The meaning of data F-molecules with non-inheritable-roles, that make assertions about role values,
is similar:
I j= o[r@arg
1
; . . . ; arg
n
!! fval
1
; . . . ; val
n
g]
holds in I if I
(n)
!!
(r
I
) is de�ned at ( o
I
; arg
I
1
; . . . ; arg
I
n
), and its set value includes the set f val
I
1
; . . . ; val
I
n
g.
The meaning of inheritable data F-molecules is de�ned similarly, using the �! and the �!! mappings.
Inheritable data F-molecules are used to select a preferred (canonical) model for an F-Logic program. The
rational behind the preference criterion is that inheritable features/roles should, preferably, propagate
down the �
U
hierarchy in an interpretation, to objects where their values are unde�ned. The propagation
is blocked by the 2
U
relation, where a single step inheritance can still apply.
Signature F-molecules assign types to features and roles. A signature F-molecule with a feature:
o[f@arg
1
; . . . ; arg
n
) (val
1
; . . . ; val
m
)];(14)
serves as a typing expression for two kinds of applications of f
I
: Application of f
I
, as a non-inheritable
feature, to objects o
0I
that are members of o
I
, and applications of f
I
, as an inheritable feature, to objects
o
0I
that are subclasses of o
I
. That is, molecule 14 provides typing to the (feature) data F-molecules:
1.
o
0
[f@arg
0
1
; . . . ; arg
0
n
! val];(15)
where o' : o, and arg
0
i
: arg
i
, for 1 � i � n, hold in I.
2.
o
0
[f@arg
0
1
; . . . ; arg
0
n
�! val]:(16)
where o' :: o, and arg
0
i
: arg
i
, for 1 � i � n, hold in I.
35
Molecules 15 and 16 are correctly typed by signature 14 if val
J
2 val
J
i
, for every 1 � i � m. Signature
F-molecules with roles account for the typing of non-inheritable and inheritable data F-molecules with
roles, in a similar fasion. The type correctness conditions, enforced on F-Logic programs, requires that
all feature/role data F-molecule are correctly typed by all signature F-molecules that can serve as their
typing expressions. For example,
(17)
son-only[ children @ Y )) ( person, male );
avgChildNo ! 4; /* Note that this is not a typing expression; it has to be
typed by yet another typing expression (see (2) below) */
wishedChildGender ) ( gender ) ]
enforces the following typing:
1. The �rst signature expression restricts the values that the non-inheritable role associated with
children
I
can take. It says that at objects o that are members of son-only
I
, these values must be
members (2 related) of person
I
andmale
I
. The formal expression of this restriction is: I
(1)
!!
(children
I
)
(o
I
; Y
I
) 2 person
I
, and I
(1)
!!
(children
I
) (o
I
; Y
I
) 2 male
I
, for every semantic structure and vari-
able assignment I of 17.
2. The non-inheritable feature associated with avgChildNo
I
must be correctly typed by another sig-
nature F-molecule like
people-group[ avgChildNo ) integer],
where son-only
I
2 people-group
I
, and 4
I
2 integer
I
, for every semantic structure and variable
assignment I of 17.
3. The value of the inheritable feature associated with wishedChildGender
I
at objects o that are
subclasses of son-only
I
must be members of gender
I
.
B.2.1 Herbrand Models { Concepts needed for the DFL Compositional Semantics
The Herbrand universe of an F-Logic language is the set of its ground id-terms. The Herbrand base of the
language is the set of its ground molecules. A Herbrand structure (H-structure) is a subset of the Herbrand
base, that is closed under logical implication. This requirement is needed since ground molecules may
imply other molecules, based on the built-in meaning of language symbols like :; ::; !; ).
De�nition B.1 (Satisfaction of formulae by H-structures)
Let H be an H-structure. Then:
� A ground molecule, t, is true in H if and only if t 2 H .
� A ground negative literal, :t, is true in H if and only if t 62 H .
� A ground clause, L
1
_ . . ._ L
n
, is true in H if and only if at least one literal, L
i
, is true in H .
� A clause, C, is true in H if and only if all ground instances of C are true in H .
A Herbrand structure H is a Herbrand model (H-model) of a set of clauses S, if every clause in S is true
in H .
36
C Background Concepts
C.1 Lattices
A set equipped with a partial ordering is a poset. Let (S;�) be a poset. A subset T of S is a chain i�
for all x; y 2 T; x � y or y � x. A sequence x
0
; x
1
; . . . is an ascending chain i� x
i
� x
i+1
; (i � o). An
element s 2 S is an upper/lower bound for T i� for all t 2 T , t � s / t � s, respectively. s is the least
upper bound (lub) / greatest lower bound (glb) for T i� it is an upper / lower bound, and for every upper
/ lower bound s
0
for T , s
0
� s / s
0
� s, respectively.
A poset S for which every subset possesses a least upper bound and a greatest lower bound is a
complete lattice. The glb/lub of S are called its least=greatest elements, respectively, and denoted ?/>.
The powerset of S with the subset ordering is a complete lattice. Its least element is ;, and its greatest
element is S. Let (S;�) be a complete lattice. A predicate p is inclusive on S i� for all chains T � S, if
p(t) holds for every t 2 T , then p(lub(T )) also holds.
Let (S;�) be a poset. A function f : S ! S is monotonic i� s � s
0
) f(s) � f(s
0
). f is continuous
i� for every non-empty chain T � S, lub(ff(t) j t 2 Tg) = f(lub(T )). s 2 S is a �xpoint of f if s = f(s).
For a complete lattice, S, the powers of f are de�ned by:
f " 0 = ?, the least element of S.
f " �= f(f " (�� 1)), if � is a successor ordinal.
f " �= lubff " �
0
j �
0
� �g, if � is a limit ordinal.
If f is monotonic then it has a least �xpoint, denoted lfp(f); if f is continuous then lfp(f) = f " !.
C.2 Logic Programs
A term is either a variable or f(t
1
; . . . ; t
n
) (n � 0), where f is a function symbol, and the t
i
-s are terms.
An atom is p(t
1
; . . . ; t
n
) (n � 0), where p is a predicate symbol, and the t
i
-s are terms. A literal is an
atom or a negation (not) of an atom. A clause is A L
1
; . . . ; L
n
(n � 0), where A is an atom, and the
L
i
-s are literals. A syntactic object is ground if it includes no variables. A definite program is a �nite
collection of clauses. A definite positive program is a de�nite program without negation.
The set of ground atoms of a logic programming language is its Herbrand base. A Herbrand interpre-
tation is a subset of the Herbrand base. A Herbrand model for a set of clauses S is a Herbrand universe
in which every clause in S holds (similar to the de�nition in F-Logic).
Let P be a de�nite positive program. The immediate consequence operator T
P
is a function on
Herbrand interpretations, de�ned as follows:
T
P
(I) = fA j 9C 2 P and a ground instance A L
1
; . . . ; L
n
of C; L
i
2 I; for all 1 � i � ng
The operator T
P
is monotonic and continuous, and hence has a least �xpoint, given by T
P
" ! =
1
[
i=0
T
P
" i.
The least �xpoint of T
P
is called the fixpoint semantics of P . It is equal to the smallest Herbrand model
of P , which is also the success set of P .
Unfolding Semantics (taken from [13])
The unfolding semantics is part of the s-semantics approach. Denotations of logic programs are
de�ned by syntactic objects, as in the case of Herbrand interpretations, but the usual Herbrand base is
extended to the set B of all the (possibly non-ground) atoms (modulo renaming). Interpretations, called
�-interpretations, are subsets of B.
37
De�nition C.1 Let P and Q be de�nite positive programs. Then the unfolding of P w.r.t. Q is de�ned
as
unf
P
(Q) = f(A : �
~
L
1
; . . . ;
~
L
n
)# j 9A : �B
1
; . . . ; B
n
2 P; 9B
0
i
: �
~
L
i
2 Q; i = 1; . . . ; n;
renamed apart; such that # = mgu((B
1
; . . . ; B
n
); (B
0
1
; . . . ; B
0
n
))g
The unfolding semantics is de�ned by an iterative construction as follows:
De�nition C.2 Let P be a de�nite positive program. Then we de�ne the collection of programs
P
0
= P
P
i
= unf
P
i�1
(P ); i = 1; 2; . . .
and the collection of �-interpretations I
i
(P ) = fA j A 2 B and A 2 P
i
g. The unfolding semantics U(P )
of the program P is de�ned as
U(P ) =
[
i=0;1;...
I
i
(P )
The unfolding semantics serves as the link between the top-down operational non-ground semantics
O(P ), and the bottom-up �xpoint non-ground semantics F(P ):
Theorem C.3 Let P be a de�nite positive program. Then F(P ) = U(P ) = O(P ).
The connection to the conventional ground semantics is given in the following theorem ([22]):
Theorem C.4 Let P be a de�nite positive program. Then the success set of P is given by the set of
ground instances of the atoms in O(P ).
We use this result, based on the equivalence between the unfolding and the operational semantics, in
Theorem D.4.
D Proofs of Theorems
Proofs of Theorems from Subsection 6.1
Claim 6.2 H(D) is a Herbrand model of D and of RULES, but not necessarily of FL
P
.
Proof: First we prove the following proposition:
Proposition D.1
1. 8i � 1; TH
i
(D) is a model of D, i.e., TH
i
(D) j= D.
2. 8i � 1; M(D[TH
i
(D)) � TH
i
(D), where for a set of F-Logic formulae S, M(S) is the minimal
Herbrand model of S, if it exists.
Proof (of proposition):
1. Let i � 1:
TH
i
(D) = DLH [TH
i�1
(D)][ RH [TH
i�1
(D)]. We show:
DLH [TH
i�1
(D)] j= D, and RH [TH
i�1
(D)] j= D.
DLH [TH
i�1
(D)] j= D holds since for every ground instance of a rule in D, if its assumption is in
DLH [TH
i�1
(D)], then it must be in all Herbrand models of D [ TH
i�1
(D)[ FL
P
. But then, the
38
consequence should also be in all of these models, and hence also in their intersection.
RH [TH
i�1
(D)] j= D holds since it is a Herbrand model of D [ TH
i�1
(D)[ RULES.
In conclusion, TH
i
(D) j= D holds since for every ground instance of a rule in D, if its assumption
is in TH
i
(D), then it is either in DLH [TH
i�1
(D)] or in RH [TH
i�1
(D)] (the assumption consists
of a single atom). Hence, its consequence is also either in DLH [TH
i�1
(D)] or in RH [TH
i�1
(D)].
Note that facts in D must be included, both, in DLH [TH
i�1
(D)] and in RH [TH
i�1
(D)].
2. For all i � 1, TH
i
(D) is a Herbrand model of D [ TH
i
(D), since for every ground instance of a
rule in D, if its assumption is in TH
i
(D), then its consequence should also be in TH
i
(D).
Note that analogous claims do not hold, neither for FL
P
nor for RULES.
Proof (of claim):
1. H(D) is a Herbrand model of D.
The property \X
i
is a Herbrand model of Y " is an inclusive property, for every chain of Herbrand
structures X
0
; X
1
; X
2
; . . ., and a set of Horn clauses Y . That is, if for all i � 0 the property
holds for X
i
and Y , then it holds for
1
[
i=0
X
i
and Y . This is true since if the assumption of a ground
instance of a rule in Y is in
1
[
i=0
X
i
, then there is some k � 0 such that the assumption is in X
k
. But
then, the conclusion is also in X
k
, since X
k
is a Herbrand model of Y . Hence, the conclusion is also
in
1
[
i=0
X
i
. The result then follows from Claim 6.1 and Proposition D.1.
2. H(D) is a Herbrand model of RULES.
Take a ground instance of a rule in RULES. If its assumption holds in H(D), then there is some
k � 0 such that the assumption holds in TH
k
(D) (the TH
i
(D)-s form a chain). Then TH
k+1
(D)
is a Herbrand model of D [ TH
k
(D)[RULES. Hence, the consequence of that ground instance is
in TH
k+1
(D), and hence in H(D).
H(D) is not necessarily a Herbrand model of FL
P
, since FL
P
may include wild formulae, depending on
the intended meaning of operators in P . 2
Proofs of Theorems from Subsection 6.2
The following claim is necessary for the proof of Theorem 6.11.
Claim D.2 For every ascending chain of sets of descriptions hD
i
i
i�0
; DLF (
1
[
i=0
D
i
) =
1
[
i=0
DLF (D
i
).
Proof: Recall that DLF (D) = fq j q 2 L
P
; D [ FL
P
j= qg.
)
Assume q 2 DLF (
1
[
i=0
D
i
). Then,
1
[
i=0
D
i
[ FL
P
j= q. By compactness of F-Logic, and since the sequence
hD
i
i
i�0
is an ascending chain, we have: For some i � 0; D
i
[ FL
P
j= q, which implies: q 2 DLF (D
i
).
Hence, q 2
1
[
i=0
DLF (D
i
).
(
Assume q 2
1
[
i=0
DLF (D
i
). Then, for some i � 0; q 2 DLF (D
i
). That is, D
i
[FL
P
j= q. By monotonicity
39
of j= we get:
1
[
i=0
D
i
[ FL
P
j= q, which implies q 2 DLF (
1
[
i=0
D
i
).
2
Theorem 6.6 If RH(D) = RF (D), and RF (D) is monotonic, then: F (D) � H(D).
Proof:
F (D) = TF
!
(D) =
1
[
i=0
TF
i
(D)
H(D) =
1
[
i=0
TH
i
(D)
1. We show: 8i � o; TF
i
(D) � TH
i
(D). We prove it by induction on i.
� Basis: i = 0:
TF
0
(D) = D � D=atom = TH
0
(D)
� Inductive hypothesis: i = k � 0.
� Inductive Step: i = k + 1; i > 0.
DLH(TH
k
(D)) = \fH j H is a Herbrand model of D [ TH
k
(D)[ FL
P
g
RH(TH
k
(D)) = The intended Herbrand model of D[TH
k
(D)[RULES = RF (D[TH
k
(D))
(by the theorem's assumption).
TH
k+1
(D) = DLH(TH
k
(D))[ RH(TH
k
(D))
TF
k+1
(D) = TF [TF
k
(D)] = DLF [TF
k
(D)][ RF [TF
k
(D)]
DLF [TF
k
(D)] = fq j q 2 L
P
; TF
k
(D)[ FL
P
j= qg �
(since TF
k
(D) � D, and by the inductive hypothesis
and the monotonicity of j=)
� fq j q 2 L
P
; D [ TH
k
(D)[ FL
P
j= qg �
� fq j q 2 L
P
=atom;D [ TH
k
(D) [FL
P
j= qg =
= \fH j H is a Herbrand model of D [ TH
k
(D)[ FL
P
g = DLH(TH
k
(D)
RF [TF
k
(D)] �
(by the inductive hypothesis and the monotonicity of RF )
� RF [D [ TH
k
(D)] =
(by theorem's assumption)
= the intended H-model of D [ TH
k
(D)[ RULES = RH(TH
k
(D)
Hence we have:
TF
k+1
(D) = DLF [TF
k
(D)][ RF [TF
k
(D)] �
� DLH(TH
k
(D)[RH(TH
k
(D) = TH
k+1
(D)
2. By (1) we have: 8i � o;
1
[
i=0
TF
i
(D) � TH
i
(D) . Hence,
1
[
i=0
TF
i
(D) is an upper bound on the
sequence hTH
i
(D)i
i�0
. Therefore, it includes the lub of the sequence, i.e.,
1
[
i=0
TF
i
(D) �
1
[
i=0
TH
i
(D) .
40
2
Proofs of Theorems from Subsection 6.3
Theorem 6.10 If the O
D;RULES
is monotonic, and its application to M(D) is included in its in�nite
iteration, i.e., O
D;RULES
(M(D)) � O
D;RULES
" !, then: F (D) � singleF (D).
Proof:
F (D) =
1
[
i=0
TF
i
(D)
singleF (D) =
1
[
i=0
TsglF
i
(D)
1. We show: 8i � 0;
For some j � i; TF
j
(D) � TsglF
i
(D). We prove it by induction on i.
� Basis: i = 0:
For j = 0; TF
0
(D) = TsglF
0
(D).
� Inductive Hypothesis: i = k � 0.
� Inductive Step: i = k + 1; i > 0:
By inductive hypothesis: For some j � k; TF
j
(D) � TsglF
k
(D).
By monotonicity of the DL reasoner:
For some j � k; DLF [TF
j
(D)] � DLsglF [TsglF
k
(D)].
By monotonicity of the R reasoner (results from assumption (1) of the theorem, and Claim
6.9):
For some j � k; RF [TF
j
(D)] � RF [TsglF
k
(D)] =
= O
TsglF
k
(D);RULES
" ! �
(by theorem's assumption)
� O
TsglF
k
(D);RULES
[M(TsglF
k
(D))] =
= RsglF [TsglF
k
(D)]
We have:
For some j � k; TF
j
(D) = DLF [TF
j
(D)][RF [TF
j
(D)] �
� DLsglF [TsglF
k
(D)][ RsglF [TsglF
k
(D)] =
= TsglF
k
(D).
2. By (1), for all i � 0; F (D) � TsglF
i
(D). Hence, also
F (D) � singleF (D).
2
The following auxiliary lemma is used in the proof of Theorm 6.11. It characterizes a continuous
behavior of the operator TsglF on chains of description sets.
Lemma D.3 If for all ascending chains of sets of descriptions D
i
, where D =
1
[
i=0
D
i
;
O
D;RULES
[M(D)] �
1
[
i=0
O
D
i
;RULES
[M(D
i
)], then: TsglF (D) �
1
[
i=0
TsglF
i
(D
i
).
41
Proof:
TsglF (D) = DLsglF (D)[RsglF (D) = DLF (D) [ O
D;RULES
[M(D)] �
�
1
[
i=o
DLF (D
i
)
!
[
1
[
i=0
O
D
i
;RULES
[M(D
i
)]
!
=
=
1
[
i=0
(DLF (D
i
) [O
D
i
;RULES
[M(D
i
)]) (by assumption and Claim D.2) =
=
1
[
i=0
TsglF
i
(D
i
).
2
Theorem 6.11 If the O
D;RULES
is monotonic, and for all ascending chains of sets of descriptions
D
i
, where D =
1
[
i=0
D
i
; O
D;RULES
[M(D)] �
1
[
i=0
O
D
i
;RULES
[M(D
i
)], then: F (D) � singleF (D).
Proof:
1. We show: 8i � 0; TF
i
(D) �
1
[
j=0
TsglF
j
(D) = singleF (D):
We prove by induction on i: If q 2 TF
i
(D) then for some j � i; q 2 TsglF
j
(D).
� Basis: i = 0:
TF
0
(D) = TsglF
0
(D). Hence, the claim holds for j = 0.
� Inductive Hypothesis: i = k � 0.
� Inductive Step: i = k + 1; i > 0:
Let q 2 TF
k+1
(D). Then q 2 DLF [TF
k
(D)] [RF [TF
k
(D)].
{ Assume q 2 DLF [TF
k
(D)].
Then, TF
k
(D)[ FL
P
j= q. By inductive hypothesis, TF
k
(D) �
1
[
i=0
TsglF
i
(D).
Hence,
1
[
i=0
TsglF
i
(D) [FL
P
j= q. By compactness of F-Logic, and since the sequence
hTsglF
i
(D)i
i�0
is an ascending chain, we have:
For some j � 0; TsglF
j
(D)[ FL
P
j= q, which implies: q 2
1
[
i=0
TsglF
i
(D) = singleF (D).
{ Assume q 2 RF [TF
k
(D)].
By inductive hypothesis, and since RF is monotonic:
q 2 RF [
1
[
i=0
TsglF
i
(D)] =
= RF [singleF (D)] =
=
1
[
j=0
O
singleF (D);RULES
" j
We show, by induction on j:
8j � 0 : O
singleF (D);RULES
" j �
1
[
i=0
TsglF
i
(D) = singleF (D).
� Basis: j = 0 : O
singleF (D);RULES
" 0 = ;.
� Inductive hypothesis: j = k � 0.
� Inductive step: j = k + 1; j > 0:
42
O
singleF (D);RULES
" k + 1 =
= O
singleF (D);RULES
[O
singleF (D);RULES
" k] �
(by inductive hypothesis, and monotonicity of O
D;RULES
)
� O
singleF (D);RULES
[singleF (D)] �
(by de�nition of TsglF )
� TsglF [singleF (D)] =
= TsglF [
1
[
i=0
TsglF
i
(D)] �
�
1
[
i=1
TsglF
i
(D) (by Lemma D.3) =
(since hTsglF
i
(D)i
i�0
is a chain)
=
1
[
i=0
TsglF
i
(D) =
= singleF (D)
From O
singleF (D);RULES
" j � singleF (D) (j � 0),
we conclude:
1
[
j=0
O
singleF (D);RULES
" j � singleF (D).
Hence we have: q 2 singleF (D).
In sum we received:
8i � 0 : If q 2 TF
i
(D) then q 2 singleF (D).
2. By (1): 8i � 0; TF
i
(D) � singleF (D): Hence,
F (D) =
1
[
i=0
TF
i
(D) � singleF (D):
2
Proofs of Subsection 6.4
The proof of Theorem 6.14 uses the following theorem that we adapt from [13,22]:
Theorem D.4 Let DR be a set of descriptions and rules, and hDR
i
i
i�0
be the sequence of sets de�ned
in the computation of ROF (DR). De�ne
I
i
(DR) = fA j A is an atom; A 2 DR
i
g; (i � 0)
Then: Success set of DR = Set of ground instances of
1
[
i=0
I
i
(DR).
Theorem 6.14 If RF is de�ned as in Equation 13, then the OF semantics is more powerful than the
F semantics. That is: F (D) � kD[OF (D)]k.
Proof:
F (D) =
1
[
i=0
TF
i
(D)
OF (D) =
1
[
i=0
TOF
i
(D [ RULES)
43
1. We prove, by induction on i: 8i � 0 : TF
i
(D) � kD[TOF
i
(D [ RULES)]k.
� Basis: i = 0:
TF
0
(D) = D � kD[D [ RULES]k= kD[TOF
0
(D [RULES)]k.
� Inductive hypothesis: i = k � 0.
� Inductive step: j = k + 1; i > 0:
TF
k+1
(D) = TF [TF
k
(D)] � (by inductive hypothesis)
� TF [kD[TOF
k
(D)]k] � (by monotonicity of TOF )
� TF [kD[TOF
k
(D [RULES)]k] =
(denote DR
k
= TOF
k
(D [ RULES) )
= DLF (kD(DR
k
)k) [RF (kD(DR
k
)k) =
= DLOF (DR
k
) [RF (kD(DR
k
k))
We now show: RF (kD(DR
k
)k) � kD(ROF (DR
k
))k.
RF (kD(DR
k
)k) = T
kD(DR
k
)k[RULES
" ! � T
DR
k
[RULES
" ! =
(since DR
k
= TOF
k
(D [RULES) � RULES, by Proposition 6.13 )
= T
DR
k" ! = (since DR
k
is a de�nite positive logic program)
=M(DR
k
) = Success set of DR
k
= (by Theorem D.4)
= Set of all ground instances of
1
[
i=0
I
i
(DR
k
) =
(since for all i � 0, I
i
(DR
k
) � L
V ar
P
=atom)
= Set of all ground instances of D(
1
[
i=0
I
i
(DR
k
)) =
= kD(
1
[
i=0
I
i
(DR
k
))k � (since for all i � 0, I
i
(DR
k
) � DR
k
i
)
� kD(
1
[
i=0
(DR
k
i
)k = kD(ROF (DR
k
))k
We received:
TF
k+1
(D) � DLOF (DR
k
) [RF (kD(DR
k
)) �
� DLOF (DR
k
)[ kD(ROF (DR
k
))k = (since DLOF (DR
k
) � L
P
)
= kD(DLOF (DR
k
))k [kD(ROF (DR
k
))k =
= kD[DLOF (DR
k
) [ROF (DR
k
)]k =
= kD[TOF (DR
k
)]k = kD[TOF
k+1
(D [ RULES)]k
2. By (1), for all i � 0,
TF
i
(D) �
1
[
i=0
kD[TOF
i
(D [ RULES)]k = kD[
1
[
i=0
TOF
i
(D [ RULES)]k
= kD[OF (D)]k.
Hence, also F (D) =
1
[
i=0
TF
i
(D) � kD[OF (D)]k:
2
44