RE: Literals (Re: model theory for RDF/S)

From: Patrick.Stickler@nokia.com
Subject: RE: Literals (Re: model theory for RDF/S)
Date: Wed, 3 Oct 2001 19:09:58 +0300 

> > If RDF supports URI schemes that have a 
> > built-in notion
> > of equality, ...
> 
> But again, we can't expect RDF to support every possible
> URI scheme and it's particular semantics -- or every known
> relation between the semantics of different URI schemes.
> 
> At best, RDF could provide generic mechanisms by which 
> those URI semantics could be defined and related -- and
> in fact, it probably does already, in RDFS (we just don't
> have that ontology defined yet).

Somehow my point is being missed here.  I'm not asking that RDF provide
support for all possible URI schemes.  I'm just asking that RDF not
preclude large classes of URI schemes, just as I'm asking that RDF not
preclude large classes of schemes for handling literals.

That's all!!

[...]

> > However, it is possible to design a system that 
> > allows access to
> > several interfaces, one to the logical level and one to the symbolic
> > level.  At the logical level, there may be no way of determining which
> > symbol is being used, to the point that queries should 
> > probably return sets
> > of symbols in many cases, and not just single symbols.  At 
> > the symbolic
> > level, there may indeed be a difference between the two 
> > symbols.  There may
> > also be other levels, such as a proof-theoretic level, where the
> > distinction also makes sense.
> 
> Good. And at what level then is the graph itself? Presumably the
> symbolic level. And at what level do applications currently
> interact with the graph? The symbolic level. And even if one
> introduces mechanisms that allow one to equate many nodes to
> the same "resource" -- how is that "schitsophrenic" resource
> going to be accessed? At the symbolic level.

All this depends on the formal underpinnings of the model theory.  In Pat
Hayes's model theory, the graph is syntactic (or symbolic, if you prefer).
Other model theories, possibly for other formalisms, may make the semantic
level BE the graph!  Yet other model theories, possibly for other
formalisms, may not have a graph at all, even though they handle the same
``information'' that RDF does.

Applications interact with the graph at whatever levels are allowed by the
API.  If the API only provides an interface to the logical meaning of the
graph, then there is no way to interact with the graph at any other level.
I do agree with you that this would be an impoverished API---you do want
access to the symbolic or syntactic level to at least some extent.

Of course, the return ``values'' of calls are not semantic, so there has to
be some way of representing semantic entities for calls that access the
semantic level.  (One way is to return all the URIs seen so far that are
known to be equivalent to the semantic entity.  There are other ways as
well.)

> I guess I'm just not seeing how this works in practice, and
> what it means to folks actually interacting with the RDF graph.

This, of course, points out a severe problem with the RDF specification.
There is no API, and thus no idea of what sorts of interactions are
permissable with respect to the graph.  In the absence of such an API many
confusions are likely.  

Let me present one possible, very limited, but theoretically adequate API.
Note that I do not think that this is a good API, I'm just presenting it as
an example.

The symbolic ``retrieval'' call is:

Regurgitate - return the graph as a (Java?) data structure using the following
	      graph representation ......

The semantic ``retrieval'' call is:

Follows?(g:graph) - return the string "yes" if the graph entails g, 
		    "no" otherwise

Both calls depend on the existence of an implicit graph that is maintained
somehow.  There should be operations for doing this, perhaps something like:

Consult(d:URI) - parse the document d and add the resulting graph to the graph
Augment(g:graph) - add the graph g to the graph
Throwaway - start over with an ``empty'' graph

Now that we have an API (that needs to be more-formally defined however),
we can talk about how everything works in practice, and whether there is
sufficient access to the various levels.


[...]

> > Please read the model theory.  Resource has a particular 
> > meaning there.
> 
> I'm working on it...  (scary stuff for poor knaves like me ;-)

If you can understand a specification like Corba or JTAPI or even the
meaning of a programming language, like C++ or ML, then you should be able
to work your way through a model theoretic specification.  After all, RDF
and DAML+OIL are a lot more simple than Corba or C++!

> Regards,
> 
> Patrick


Peter F. Patel-Schneider

Received on Wednesday, 3 October 2001 13:29:32 UTC