W3C home > Mailing lists > Public > semantic-web@w3.org > December 2005

Re: Formal Semantics of OWL + RDF + SPARQL + SWRL

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Thu, 08 Dec 2005 10:20:06 -0500 (EST)
Message-Id: <20051208.102006.130530576.pfps@research.bell-labs.com>
To: danny.ayers@gmail.com
Cc: adrianw@snet.net, semantic-web@w3.org

From: Danny Ayers <danny.ayers@gmail.com>
Subject: Re: Formal Semantics of OWL + RDF + SPARQL + SWRL
Date: Thu, 8 Dec 2005 14:12:07 +0100

> On 12/7/05, Peter F. Patel-Schneider <pfps@research.bell-labs.com> wrote:
> > > > I agree that there is the possibility of allowing stores that have different
> > > > functionality.  I do not believe, however, that the current vision of the
> > > > Semantic Web supports a good way of providing this.
> > >
> > > Do you have any (links to?) alternative visions which would be more suitable?
> >
> > You might look at
> >
> > Peter F. Patel-Schneider. A Revised Architecture for Semantic Web
> > Reasoning. Third Workshop on Principles and Practices of Semantic Web
> > Reasoning. Dagstuhl, Germany, September 2005. LNCS 3703, Springer Verlag, 2005.
> > http://www-db.research.bell-labs.com/user/pfps/publications/architecture.pdf
> Thanks Peter. So if I understand correctly, essentially you're
> suggesting we use multiple syntaxes, different ones for different
> layers of the SW stack.
> The only way I can think this might be helpful in maintaining a Web
> containing stores of different functionality, would be that they had
> very different interfaces. This seems to sidestep the issue of stores
> containing identical data responding differently to the same query
> (depending on their inference capability), and it also seems contrary
> to the conventional wisdom of uniform interfaces being good things. Am
> I missing something?

Yes, there are also fundamental technical reasons why a single syntax is not
appropriate for the Semantic Web.  Essentially the argument is that if you have
the power of FOL (first-order logic), a truth predicate (needed, for example,
to embed FOL in RDF), and some sort of syntax construction (needed, for
example, to build the FOL sentences) then your formal systems breaks down
(because you get some variant of the liar's paradox).  This argument is very
robust - there is no reasonable way around it.

Further, I disagree completely with the applicability of the "uniform
interfaces" argument here, either for user interfaces or computer interfaces.

First, the user interface to FOL (or OWL, or rules) in RDF is not uniform with
the user interface to non-FOL (or ...) RDF.  In one case you are entering
facts; in the other you are entering syntax.  In fact, I would go even further
and say that even entering RDF facts does not call for a uniform user interface
at all!  Why should the user interface for FOAF data be the same as the user
interface for DC data?  You are entering different sorts of data, after all.
How would you feel if all web user-entry forms had exactly the same format?

Second, the program interface to FOL (or ...) in RDF is only uniform with the
program interface to non-FOL (or ...) in RDF at the lowest, least-interesting,
and least difficult level.  Consider, for example, the conniptions on has to go
through to just identify OWL constructs in RDF triples.  The problem would be
just as bad for other languages, like FOL or rules.

> (Looking on your arguments in the paper more generally, I'm afraid the
> overarching semantic problems of RDF/triple-based representation of
> layers further up the stack aren't as obvious (to me at least) as you
> imply in the paper. The concrete syntax issues aren't really a
> showstopper when syntax transformation tools are readily available (as
> you'd probably agree). As you say in the paper, multiple syntaxes
> wouldn't really call for additional work within applications because
> they're looking at the model anyway. So on the one hand I can't
> actually see the need for multiple syntaxes, on the other wouldn't
> really have a problem with working that way...).

See the technical argument above.

See also the interface argument above.  In my opinion, it is significantly
harder to write a recognizer for OWL (or FOL or rules or ...) written in RDF
triples (and remember that this is *after* the RDF parsing has already
happened) than it is to write a good parser for OWL (or ...) written in any
decent syntax (and also written in XML).

I do not believe that the current syntax transformation tools are really up to
the task of transforming FOL (or OWL or ...) in RDF in XML into FOL (or ...) in
whatever.  Remember that the triples for a particular bit of FOL (or ...) can
be spread throughout an RDF in XML document.  However, I don't know about
all the current syntax transformation tools.  Why don't you give it a try?

> Cheers,
> Danny.

Received on Thursday, 8 December 2005 15:20:43 UTC

This archive was generated by hypermail 2.4.0 : Tuesday, 5 July 2022 08:44:55 UTC