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

>[...]
>>  I may simply have not been following the point properly. Coming from
>>  logic, I have an acute sense of the difference between information
>>  which is conveyed as part of the very syntax of a language, and that
>>  conveyed by making assertions in the language. This seems like a very
>>  sharp and important distinction to me. My understanding of the
>>  proposal was that the syntactic encoding of, say, integers implicit
>>  in the notion of literal was to be abandoned and replaced by an
>>  assertional encoding in RDF triples. That may be a good idea, but it
>>  does potentially throw away a lot of valuable properties implicit in
>>  the syntactic typing of literals. However, if this proposal is better
>>  thought of as one to introduce a more uniform notion of syntactic
>>  typing for URIs in general, then I'm all for it. Sorry if my
>>  ignorance is a barrier to communication.
>
>that is indeed the crucial point!
>let me refer to our "tangent point" testcase
>   http://www.agfa.com/w3c/euler/tpoint.n3
>   http://www.agfa.com/w3c/euler/tpoint-facts.n3
>which is making use of "an assertional encoding in RDF triples"
>(think about log:implies as an entailment between graphs)
>I think this example should make use of some (primitive)
>datatypes, but only to a certain extent, because when
>the granularity is too big, I don't see straightforward
>inferincing capability to have answers to such questions as
>   http://www.agfa.com/w3c/euler/tpoint-query.n3
>especially while having a given point within the circle
>(2 complex solutions) which is later maybe "ruled" out by
>the inference engine (using further rules of course).

Well, it all depends on what you mean by 'straightforward 
inferencing' . I would say that the use of log:implies goes beyond 
RDF inference already, so I see no harm in allowing some inferential 
extensions that are capable of doing things like treating integers 
specially, calling out the inference engine to an arithmetic 
equation-solver, for example. Industrial-strength inference engines 
often do this kind of thing. I think SNARK has a general-purpose way 
of defining them and attaching them to the unifier. The Cyc inference 
engine has about 25 special-purpose callouts for things like partial 
order embeddings, checking graph matching, temporal interval 
reasoning and so on. I imagine that useful categories of literal 
would have appropriate inference subengines definable for them. This 
does go beyond a basic RDF reasoner, but then literals go beyond 
basic logic, so that's what you would expect, no?

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 Friday, 5 October 2001 17:57:11 UTC