# [seek-dev] Re: owl.pl

Bertram Ludaescher ludaesch at sdsc.edu
Fri Oct 3 10:31:27 PDT 2003

```Hi Thau:

No, that's not what I meant. The difference is roughly this

(I'm cc-ing to SEEK-dev,GEON-KR, and SEEK-Taxon since others may be
interested.  Apropos: Shawn, I just signed up for SEEK-Taxon).

Some background info: Thau had found a nice OWL package for
SWI-Prolog, and my question was whether it supports checking for
concept subsumption. I think it doesn't, but haven't checked
carefully.

So here is the (fuzzy) problem: Determine whether some concept 'B' is
a "subconcept" of (or "subsumed by") 'A'.

Here we're lumping things together a bit, so let's try to sort things
out:

Approaches:

(1) TABLE LOOKUP/EXPLICIT/EDB APPROACH:

This means: just look-up in a table subconcept(X,Y), whether you find
the pair ('B','A') in there. If yes, you know that B "isa" A.  How did
the tuple get there? Well, someone put it there, thereby explicitely
stating that B isa A.  That's more or less underlying the RDF
approach: just state the facts (S,P,O)

One can call this also the EDB approach since you can think of this as
an Extensional Database (EDB) having facts of the form:

isa('B',A').
isa('C',B').
...

You can complicate this arbitrarily by putting it in RDF syntax or
making 'subconcept' a relation:

rdf_triple('B', isa, 'A').
...

But it's still an explicit set of assertations stating what is a
subconcept of what.

Any relational database is good for this approach.

(2) RULE APPLICATION/INTENSIONAL/IDB APPROACH:

This is when you have in addition to a database of facts (EDB) as
above, some logic rules (Datalog like) that derive new
relationships. For example, you may want to intensionally define that
the subconcept relationship shall be transitive. Let's call the
transitive version "isa_tc" (transitive closure of isa):

isa_tc(X,Y) <- isa(X,Y).
isa_tc(X,Y) <- isa_tc(X,Z), isa_tc(Z,Y).

when evaluated under a suitable rule semantics (say least fixpoint),
as set of isa facts together with the isa_tc rules define a new set of
isa_tc facts, e.g., from isa(b,a) and isa(c,b) it FOLLOWS now that
isa(c,a).

Things like that can easily be done in Prolog (with some caveats), and
in deductive databases. To some extent you can use relational
databases having recursion. Or you may use an XQuery engine (but have
to code the recursion)

(3) REASONING APPROACH:

This is the one I was really after. It is the approach in which you
simple state the logic axioms for 'A' and 'B' and then try to decide
whether in ANY database instance that satisfies the axioms, it
NECESSARILY holds that "every instance of B isa instance of A".
This is the realm of the description logic folks. So you have axioms
saying that A has so-and-so properties and is contained in so-and-son
other concepts; simililary for B. Then you try to reason with those
axioms and verify (or falsify) whether x in B implies x in A.

For this kind of reasoning, you need a specialized description logic
reasoner, e.g., Ian Horrock's FACT, or a general purpose first-order
logic reasoner.

A simple way to summarize/distinguish (1-3) above is as follows:

(1) simple queries against a given fact base/database D
(2) queries against a given database D and set of rules R
(3) given a set of axioms A, ask whether for ANY database D (so no
database is given!) you can show that a concept definition C1
implies another concept definition C2

Bertram

>>>>> "t" == thau  <thau at learningsite.com> writes:
t>
>> Thau, Shawn:
>>
>> Didn't check this carefully yet, but it doesn't seem to do subsumption
>> checking, does it?
t>
t> Well... if you mean can you check to see if one class subsumes another,
t> there's a predicate in the rdfs module called rdfs_subclass_of(?Subclass,
t> ?Class) which returns true for class hierarchy subsumption.  For property
t> subsumption, there's a similar rdfs_subproperty_of predicate.
t>
t> Is that the sort of thing you mean?
t>
t> I'm not sure how smart it is about inherited properties, but I'll check
t> that out soon.
t>
t> thau!
t>
t>
t>

```