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

Re: What is an RDF Query?

From: Sandro Hawke <sandro@w3.org>
Date: Tue, 11 Sep 2001 15:34:17 -0400
Message-Id: <200109111934.f8BJYHD04872@wadimousa.hawke.org>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
cc: www-rdf-rules@w3.org

> > 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.

I would love to have at least Horn logic in "standard" RDF, but I'm
guessing it's not going to happen.  So we have layered standards.  One
standard specifies the simple syntax, and some others, layered on top of
it, specify how to convey information about particular domains in that
base syntax. 

What's interesting is how the upper layers can be developed
independently and still be (mostly) interoperable.

Pantone might define an ontology for colors, and the AKC might develop
one for breeds of dogs, and I can publish RDF information saying my
dog is an Akita (a term from the AKC vocabulary) who is Black and
White (terms from the Pantone vocabulary).

Of course, in LISP you can load libraries from different providers and
generally use the functions on the same data structures, etc.  This
kind of modularity is not new or terribly special.   RDF is more
draconian than most programming language systems in keeping identifier
spaces from colliding and in saying the "core" has very, very little
functionality.   (But then, what can you write in C without using any
libraries?   Can you do any I/O?)

It seems very natural to put the vocabularies for things like colors
and breeds of dogs "above" the language, and I think it's a good goal
for world-wide standards to put as much as possible above the
language.  I would not have chosen to put logic (and numbers) above
the language, and I'm still wondering what kind of a system we can
really build if we do so.   

There are so many usage scenarios.....

I want to be able to say "a" and "a implies b" and know that the
receiving agent will infer "b".   If we can't know that with some kind
of likelyhood, maybe there's not much point to it, and we should just
say "a" and "b" in the first place.

Anyway, we can pick a few ontologies, including ones for numbers and
first-order-logic (and maybe description logics and DAML research
groups :-) and call that "The DAML Standard Set of RDF Ontologies
v0.1" (or just "DAML") and hope that's what ends up being implemented

> 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. 

I don't know what "implementing proof theories" means, though I've
heard the term a few times.  I'd be grateful for a brief explanation
and/or pointers.   (I suspect I have the notion without quite knowing
the term being used for it.)

>                                                  (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.)

To be clear to a fault: I don't believe anyone can do anything in RDF
without defining new terms out-of-band.  (Dan Connolly suggests on irc
two useless exceptions: "deduce A from (and A B), and deduce (exists
(?x) (p ?x o)) from (p s o)".)

Defining new terms in RDF is identical to extending the language.

Alas, I'm not qualified to do more than wonder about the theory mess
this creates.

If we had a more expressive language, we could define some terms
inside the language, which would be nice, but we can't.  The question
is, would it really matter, since we could never define colors and
breeds of dogs in the language, and that's what we really want to talk
about anyway?     

(Again, there are so many different things people want to do with the
semantic web.....   Sorry for rambling.)

     -- sandro
Received on Tuesday, 11 September 2001 15:36:00 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 2 March 2016 11:10:12 UTC