W3C home > Mailing lists > Public > www-rdf-rules@w3.org > September 2001

Re: What is an RDF Query?

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Tue, 11 Sep 2001 09:48:57 -0400
To: sandro@w3.org
Cc: www-rdf-rules@w3.org
Message-Id: <20010911094857J.pfps@research.bell-labs.com>
From: Sandro Hawke <sandro@w3.org>
Subject: Re: What is an RDF Query? 
Date: Tue, 11 Sep 2001 08:57:14 -0400

> Rather that go into a lengthy reply, can I just say "layering" and
> point out that I said "LISP syntax" (atoms and dotted pairs) not "the
> LISP programming language" (with lambda and everything).  Is that
> enough?  RDF clearly can't talk about the color of my dog without us
> defining some terms (that is, extending the language), and the same
> goes for talking about rules, queries, ontologies, schemas, and (if
> we're as pure as I think we should be in defining the bottom layer)
> bags, sequences, statements, and types.
> 
>     -- sandro

Certainly, you can say ``layering'' and ``LISP syntax'', but that doesn't
explain how it would work.

The beauty of LISP is two-fold: 1/ a simple syntax, and 2/ an elegant
programming language.  If you take away the programming language, then the
syntax is not nearly as useful.

Closer to home, consider the situation with first-order logic.  The beauty
of first-order logic is not (just) its (relatively) simple syntax.  A
beauty of first-order logic is, instead, in its, dare I say it, programming
language.  That is, first-order logic has sufficient power to have
statements (axioms) that can implement many things that one might want to
do.  This power does not come from the syntax of first-order logic, but
instead comes from its semantics.

You don't have to extend first-order logic to get (some) of what you want
with modalities.  You can, instead, implement a proof theory for modal
logic inside first-order logic.  Of course, you do pay a price for this, as
these axiomatizations are not likely to work well with current first-order
provers.  (I also claim that there are other prices that you pay for this
sort of implementation.)

The situation is much different with less-expressive representational
systems, like RDF.  In such systems, there is no possibility of
implementing proof theories within the system itself.  To me, this makes
a syntactic encoding into RDF not very useful.  (If, however, you are
proposing an extension to RDF, that would be different.  Of course, an
extension needs a lot more than just a syntax.)

Peter F. Patel-Schneider
Bell Labs Research
Received on Tuesday, 11 September 2001 09:49:41 GMT

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