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

Re: What is an RDF Query?

From: Pat Hayes <phayes@ai.uwf.edu>
Date: Wed, 12 Sep 2001 14:17:08 -0500
Message-Id: <p05101001b7c558ee556e@[205.160.76.192]>
To: Sandro Hawke <sandro@w3.org>
Cc: www-rdf-rules@w3.org
>  > >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.
>>
>>  That doesn't seem to make sense. The syntax itself conveys no
>>  information at all; any language conveys information by virtue of its
>>  semantics. What is the sense of 'layering' that allows the base
>>  syntax to convey more than can be said in its own 'base' semantic
>>  theory? If you are writing RDF, what you mean is what is specified by
>>  the RDF semantics.  If you want to say more than that, you have to
>>  use some other language (which may be an extension of RDF, in the
>>  sense that FOL is an extension of propositional logic; but it is
>>  still a different language.). No amount of 'layering' is going to
>>  make the RDF syntax mean anything more than it means already.  Even
>>  if you manage, by some notational miracle, to 'use' the RDF syntax or
>>  data model to encode your new language, the result still isn't RDF;
>>  it just *looks* like RDF, but it *means* something different. That
>>  introduces ambiguity deliberately as a design strategy, which seems
>>  like a bad idea to me.
>
>Perhaps the confusion is in calling RDF a language.   I don't care for
>the word "Resource" in the acronym, but "Description Framework" seems
>pretty good.

Seems like a language to me. (If your point is that using graphs as a 
syntax is unusual, I agree; though not unprecedented. )

>
>RDF says: when you want to convey information, do it in <object,
>property [relation], value> triples.  And it gives an XML syntax for
>those triples, and some more details.
>
>And it provides some guidance (which may do more harm than good) about
>what symbols one should use in those triples to denote certain
>important objects, like the 'type' property, or web pages.
>
>But maybe calling that a "language" is overblown.  To have a language,
>you really need to define what objects are being represented by your
>symbols,

I wouldnt say that was a defining criterion. (Russell once said that 
mathematics was the subject where people didnt care what they were 
talking about or whether or not what they were saying about it was 
true. )

>I guess, and RDF sure doesn't do that.  The ppople using RDF
>for particular applications do that -- but in doing so they are
>defining *in english* what their symbols mean.  And therefor making
>some language (probably with informal semantics).
>
>But because they are using RDF syntax, their language and someone
>else's language can be combined meaningfully.

No. If they are using the same syntax, then they can be combined. For 
them to be combined *meaningfully* they had better be using the 
syntax in the same way, ie with a common semantics. If they are using 
the same syntax in different ways and don't know it, they will just 
be producing mutual confusion. If machines rely on that mutual 
confusion, chaos will be produced.

>I wish I knew a good way to for us to be clear about this with each
>other.   There may well be real, fundamental problems with the system,
>but damn if it isn't hard to tell amongst all our linguistic
>confusion.
>
>>  RDF IS NOT A PROGRAMMING LANGUAGE!  ASSERTIONAL DESCRIPTIVE LANGUAGES
>>  ARE FUNDAMENTALLY DIFFERENT FROM PROGRAMMING LANGUAGES!!  THEIR
>>  SEMANTICS DON'T WORK THE SAME WAY!!!
>
>Sorry, I understand the difference between imperative and declarative
>systems, but I don't see why that's relevant in discussing
>modularization.

I wonder if I can summarize this in an email message. Here's one way 
to put it; why would you *expect* to get modularization? If you look 
at the semantic theories of almost any logical language, the 
'meanings' of any nonlogical symbol depend, in general, on the 
meanings of all the other symbols. They combine to restrict the 
possible interpretations, but any kind of syntactic modularization is 
the exception rather than the rule. In programming languages the 
situation, typically, is different, and this is possible because 
programming languages rely on the underlying assumption of domains 
consisting of finite entities with recursive definitions. These 
domains have the basic character that their entities are *completely* 
defined by their code, rather than being *partially* characterized by 
the descriptions that are true of them. It is this characteristic 
'totality' of a recursive definition - captured in essence by the 
second recursion theorem, the one that says that every set of 
equations has a unique minimal fixedpoint - that makes it possible to 
completely characterize the computational meaning of modules in C 
libraries, independently of what uses those modules may get put to in 
other code: it makes sense of the define/call distinction (there is 
no such distinction in a general logical language, you may have 
noted.)

>In particular, the appeal to C, which is of course a
>very different language, was to the idea that external modules can be
>written in a more expressive language (eg one capable of doing I/O).
>(In fact in C that's done via the asm language construct, but normal
>programmers never use that; it's hidden in the library.)

The key point is the interface between the 'modules'. If you can 
define an interface between two logical languages, one more 
expressive than the other, which works only 'one way', then maybe you 
could build a kind of modular library extension. It would be hard to 
characterize the expressiveness of the combined language, but that's 
a theoretician's worry.

>
>>  >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 have no idea what you are talking about. Can you expand on this
>>  idea of "above" ?
>
>above = layered above = not expressible in the language, but
>expressible in the language with some extensions.

OK, thanks. Sometime, could you say why you think it is good for a 
world-wide standard language for interchanging content to be *unable* 
to express as much as possible?

>
>>  > 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".
>>
>>  Interesting point. I don't think that you can possibly know that they
>>  WILL make any inference, no matter how obvious it is. What you should
>>  be able to say is that they COULD make that inference.
>
>Yeah, I really do want "should" for some applications and that's a lot
>more like imperative programming than declarative.   I'll need to
>think about that some more.
>
>>  > 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
>>  >everywhere.
>>
>>  That doesn't make sense. An ontology is a set of assertions *in a
>>  language*. What language are you going to write the 'ontology for
>>  first-order logic' in? And what would it *say* about first-order
>>  logic, in any case? (Would it define the model theory? )
>
>In English, or whatever you'd use to define FOL in a textbook.  Maybe
>I'm misusing the word "ontology" and should stick with "vocabulary" or
>something.

OK, never mind the terminology. The more substantive point is the 
idea that the meaning of logic is given in English. This curious 
misapprehension seems to be widespread. Since about 1945, the 
meanings of formal logics have been given in mathematical terms 
(usually set theory), not English. That is why it is possible to 
manipulate logic using machines. (If the computers had to first 
understand English, we wouldn't even be able to send email to one 
another.)

>....> >
>>  >If we had a more expressive language, we could define some terms
>>  >inside the language, which would be nice, but we can't.
>>
>>  Surely the moral should be, that we should use a more expressive
>>  language. There are plenty available. (Exactly how expressive is
>>  admittedly a matter for reasonable debate, but the sweet spot for
>>  machine utility and human usefulness is almost certainly nearer to
>>  DAML+OIL than to RDF, no matter what your criteria are. If you are
>>  chiefly interested in proof-checking rather than proof generation, as
>>  Tim B-L seems to be, then the sweet spot is probably the other side
>>  of FOL, somewhere in type theory.)
>
>How can we possibly standardize this?

?? What's the problem? The usual way: form a committee, have it 
collect views, argue a lot, come to a decision, etc., then publish a 
standard. In fact its already been done several times (KIF 3.0, CGs 
(an ISO standard), IEEE-KIF (still going on, but..), etc.)

>  Maybe we should just
>standardize on a syntax and let people use a few different logics?
>(And maybe call that syntax "RDF".)
>
>>  >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?
>>
>>  We can't *define* them in the sense of giving necessary and
>>  sufficient conditions, but we can *describe* them well enough to do
>>  some useful inferencing. Really, we can, nothing exotic or
>>  challenging about it, it's old technology, widely deployed. All that
>>  needs to happen is that the W3C needs to actually learn about this
>  > stuff instead of re-inventing wheels with their spokes missing.
>
>Oh, oh, I think I finally get the gist of the W3C well enough to
>answer that!  :-)   Answer: the W3C doesn't invent technology like this.

Oh, crap. Forgive me, but the W3C is just another bunch of folks like 
all other bunches of folks, and it works exactly the same way. It 
invents things and gets all huffy and protective about its own 
inventions, just like everyone else does. It invented RDF and RDFS, 
and it probably wishes it had invented XML.

>It just facilitates others in trying to come to some working
>consensus, to allow interoperability, when the technology is mature
>enough to make that possible.  (RDF was ready for the application of
>labeling web page content, which is how it became a W3C
>Recommendation.

So did RDF just fall down from the sky? The entire RDF effort 
embodies technical terminology that are only found in W3C documents 
(eg the term 'resource'). It was invented by W3C, not by the world 
wide community. The rest of the world is waiting impatiently for W3C 
to get its act together. Which reminds me, I ought to be doing other 
things than answering email.....

Pat
-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes
Received on Wednesday, 12 September 2001 15:17:19 GMT

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