Re: On equivalence of tidy/untidy (was: Re: Reopening tidy/untidy decision)

Frank Manola wrote:

> Sergey Melnik wrote:

[...]

>> My impression was that key arguments for untidiness built on the 
>> assumption that using strings as ranges of properties such as 
>> dc:Creator or :age was inacceptable, and had to be effectively 
>> forbidden by treating untyped literals as a kind of labeled 
>> existential variables. All I wanted to clarify is that doing so simply 
>> elevates the problem of heterogeneity one level higher, and does not 
>> help applications to interoperate.
> 
> 
> 
> I believe that some of Patrick's arguments in favor of untidiness tended 
> to go too far in this direction, but I think your argument here is too 
> "binary".  That is, it seems to say that providing *some* additional 
> information in the form of a datatype doesn't help interoperability; you 
> must either provide *all* the semantics (a never-ending task), or you do 
> no good.  I don't agree with this. 


Neither do I ;) Above I'm saying that interpreting untyped literals as 
untidy does not help to interoperate. Explicit datatyping is definitely 
a step forward.

[...]

>> My conjecture is that there is no way to distinguish whether an 
>> application deploys tidy or untidy semantics. Therefore, it's an 
>> implementation detail, which matters only for defining a standard, 
>> W3C-blessed RDF API, and is irrelevant for the spec we are working on.
>>
> 
> 
> I may be wrong, but it seems to me that what you're talking about above 
> isn't the tidy/untidy distinction we're trying to sort out.  You seem to 
> be distinguishing between different ways of *representing* the literal 
> values.  We've been trying to distinguish between different *semantics*.


Well, I tried to *abstract out* the different ways of representing the 
literal values by considering an application as a black box. I also 
suggested a procedure for testing which semantics is deployed by an 
application.


>  The fact that the two approaches you describe behave the same way seems 
> to illustrate that you're only talking about one kind of semantics. 
> This  potential confusion is one of the reasons why, in an earlier 
> message, I asked that people clarify what definitions of "tidy" and 
> "untidy" they were using.  To state the tidy/untidy distinction I think 
> we're trying to deal with, in an earlier message to rdf-comments (using 
> the <Jenny> <ageinyears> "10" example), Brian characterized the 
> difference as:
> 
> tidy--the <ageinyears> property takes a value which is a numeral, i.e., 
> a string
> 
>  untidy--the <ageinyears> property takes a value which is some datatype 
> value whose string representation is "10", but without further 
> information, such as a range constraint, we can't tell exactly what the 
> value is, e.g., the string might be in octal.


The above characterization seems intuitive, but it does not specify a 
formal way of testing the difference. As I replied to DanC, we are 
trying to grasp the semantics of a non-existing (query) language, which 
is not part of the spec. That's the problem. If we want the apps to do 
one or another entailment, we have to specify entailment formally, as a 
relation on graphs, and require each application to be able to carry it 
out. I doubt that this is what we want.

To illustrate, this is how one might think about the transitivity of 
rdfs:subClassOf: Each application that complies with the semantics 
defined in the spec must behave equivalently if in each input to the 
application we replace

A rdfs:subClassOf B, B rdfs:subClassOf C
by
A rdfs:subClassOf B, B rdfs:subClassOf C, A rdfs:subClassOf C

or the other way around.

To be able to say something about tidiness, we need a similar 
specification. My conjecture is that there is no way to produce such 
specification, unless we want to standardize syntactic entailment, which 
is a different story.

Sergey


> Similarly, the last RDF Datatyping working proposal (Part 1 of which we 
> have already adopted) says, in Part 2 section C:
> 
> "If inline literals are to be addressed by RDF Datatyping, then a choice 
> must be made between interpreting inline literals as having string 
> semantics (also called tidy semantics) such that each literal would be 
> treated as a global string constrant, or interpreting literals as having 
> value semantics (also called untidy semantics) such that the literal is 
> taken to denote a datatype value and its interpretation depends upon the 
> context within which it is used, such as the property and any datatype 
> range defined for the property."
> 
> It's not clear to me that the two alternative implementions you've 
> described get at this distinction.
> 
> --Frank
> 
> 
>

Received on Tuesday, 1 October 2002 05:33:38 UTC