W3C home > Mailing lists > Public > www-webont-wg@w3.org > October 2002

WG: Refactoring OWL Lite - a proposal based on implementation inrule-based systems

From: Raphael Volz <volz@aifb.uni-karlsruhe.de>
Date: Sat, 5 Oct 2002 00:00:57 +0200
To: "Webont" <www-webont-wg@w3.org>
Message-ID: <DMECLAFLIOFJEFFIAJPCCEMHDAAA.volz@aifb.uni-karlsruhe.de>

I just thought a little bit more about enumeration.

copying from dan's reply...

The owl syntax looks like that
	:MyBrothers owl:oneOf (:Bob :John).
to
	:Bob rdf:type :MyBrothers

with a rule:

	C(X) :- oneOf(L,C), member(L,X).

we create the extension of C (all enumerated members)

we don't want to let any other individuals creep in, if
so this is inconsistent.

Let's capture the semantics of type wrt. to subClassOf
(this is different from the document)

type(X,C) :- type(X,D), subClassOf(D,C).

then we can use the check the consistency via instantiation
of the following rule:

inconsistent(X,Y) :- oneOf(L,X), type(Y,X).

this uses the fact that all instances for enumerated classes
are not *syntactically* represented via rdf:type of the enumerated
class.

It is getting late, so I might be wrong...

Correct ?

Raphael
-----Ursprüngliche Nachricht-----
Von: Raphael Volz [mailto:volz@aifb.uni-karlsruhe.de]
Gesendet: Freitag, 4. Oktober 2002 22:29
An: Dan Connolly
Betreff: AW: Refactoring OWL Lite - a proposal based on implementation
inrule-based systems


Hi Dan

actually I just copied section 4 from a previous paper on
views, where the binary representation comes in very handy.

Of course, your alternative would work out fine as well.

The problem with enumeration is that we have no means to
close the extension of the class. Hence, someone could
say

:RaphaelsSisters owl:subclassof :MyBrothers

and all of the sudden my sisters would also be your brothers.
One could do that outside of the logic, though.

Raphael
-----Ursprüngliche Nachricht-----
Von: Dan Connolly [mailto:connolly@w3.org]
Gesendet: Freitag, 4. Oktober 2002 22:17
An: Raphael Volz
Cc: Webont; ls3
Betreff: Re: Refactoring OWL Lite - a proposal based on implementation
inrule-based systems


On Fri, 2002-10-04 at 12:21, Raphael Volz wrote:
[...]
> The proposal is motivated by Datalog theory, and
> can be easily implemented on top of cheap, existing, off-the-shelve and
> widely availabe technology.
[...]

Why do you separate the statements in an ontology from other
sorts of statements?

In section 4 Representation of RDF in rule-based systems, I
see the straightforward prolog representation of RDF triples...

  OWL ontologies are syntactically represented in RDF. This would
  allow a very simple form of representation,which maps each
  RDF statement to one logical ternary predicate
  statement(subject, predicate, object).


(statement is called 'rdf' in our recent work with otter,
and it's called PropertyValue in the DAML+OIL KIF axioms)

But then why do you use the rule schema...

  D(X) : - C(X).

for subClassOf, rather than the straightforward representation
	statement(D, rdfs:subClassOf, C).
along with one generalized rule...
	statement(X, rdf:type, D) :- statement(D, rdfs:subClassOf, C),
		statement(X, rdf:type, C).
?

That would get around some of the problems with enumerations; e.g.
we can get from
	:MyBrothers owl:oneOf (:Bob :John).
to
	:Bob rdf:type :MyBrothers

with a rule:

	statement(X, rdf:type, C) :- statement(C, owl:oneOf, L),
		statement(X, owl:member, L).



--
Dan Connolly, W3C http://www.w3.org/People/Connolly/
Received on Friday, 4 October 2002 18:02:55 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:57:53 GMT