RE: Datatyping Summary

Jeremy, as far as I can tell, you are proposing:

(a) start with datatyping scheme S, complete with its model theory 
(significantly, a literal denotes exactly the corresponding string).
(b) avoid subgraphs of the form <a> <foo> "ss" . by preprocessing them into
     <a> <foo> _:b . _:b rdf:value "ss" .

I think this does address the self-entailment problem.

But I think that adding the requirement for graph transformation will be a 
different kind of show stopper, in that lots of deployed software will see 
<a> <foo> "ss" . and generate a graph containing exactly one arc.

I'm puzzled by this:

> >From an implementators point of view, it is clearly easier to implement the
>syntactic transformation and S-P, than to implement S-A, S-B and S-P.

I don't think an RDF implementation has to do anything special to process 
S-A, S-B and S-P that isn't standard RDF handling.  Without any extension 
to core RDF, I could define a vocabulary+interpretation that models these 
idioms, giving them their intended interpretation, so what's special here 
for the RDF processor?

#g
--

At 12:24 PM 1/29/02 +0000, Jeremy Carroll wrote:

>This message addresses the main criticisms of TDL.
>I will follow up with more detail concerning query, Brian's B3 & B4.
>
>The proponents of S furnish us with an implementation of S, and a model
>theory for S (which includes, naturally self-entailment).
>
>I now can create an implementation of TDL in the following fashion.
>
>As I read in any RDF graph I apply the following syntactic transformation.
>
>Match:
>   ?x  ?y ?z
>   where ?y != rdf:value and
>         ?z a literal node
>
>   replace with
>   ?x ?y NewNode
>   NewNode rdf:value ?z
>
>   where NewNode is a newly minted bNode.
>
>For example:
>
><a> <foo> "ss" .
>
>is transformed to
>
><a> <foo> _:b.
>_:b <rdf:value> "ss".
>
>
>We then use the S implementation and S model theory (idiom S-P is the only
>idiom used).
>
>Hence:
>   If S is implementable then so is TDL
>   The maximum overhead required for TDL is the same as that for S idiom A
>and/or S idiom P.
>
>All problems to do with entailment, query, implication, etc. are clarified
>and addressed with this process (as long as they are clear and addressed
>with S).
>
> >From an implementators point of view, it is clearly easier to implement the
>syntactic transformation and S-P, than to implement S-A, S-B and S-P.
>
>Graham, does this adequately address your concern about self-entailment?
>
>[Small technical detail:
>
>S-P uses a closed world assumption on data types, whereas TDL uses an open
>world assumption. The two can be made equivalent by using S-P with at least
>two incompatible types in its closed world  both having domain being the
>complete set of unicode strings. Two such types are:
>
>xsd:string = { < x, x > | for any unicode string x }
>appendA    = { < x, x."A" > | for any unicode string, . being string
>concatenation }
>
>]
>
>Jeremy

------------------------------------------------------------
Graham Klyne                    MIMEsweeper Group
Strategic Research              <http://www.mimesweeper.com>
<Graham.Klyne@MIMEsweeper.com>
        __
       /\ \
      /  \ \
     / /\ \ \
    / / /\ \ \
   / / /__\_\ \
  / / /________\
  \/___________/