Re: RDF Extensibility

On Jul 8, 2010, at 2:28 PM, Toby Inkster wrote:

> On Thu, 8 Jul 2010 12:16:06 -0500
> Pat Hayes <phayes@ihmc.us> wrote:
>
>> I would veto this option. To do this would be a lot more work than
>> not doing it; and it would greatly complicate the semantic
>> specification, which would have to keep track of this
>> 'meaninglessness'.
>
> Why would tools need to keep track of the meaninglessness? True
> "meaning" is only assigned to triples by their human consumers.
>
>> One could have a situation, for example, in which A entails B entails
>> C, A and C are perfectly fine, but B has been declared 'meaningless'.
>> Should this inference be blocked? Should it be an error?
>
> No, and no. While B is meaningless in itself, C might not be.
> Rules/entailments operate over symbols, not over meaning.

Not exactly. See below.

> It's
> perfectly feasible that something meaningful might be discovered by
> applying a set of rules to symbols that are meaningless.
>
> An entailment that generates a meaningless statement is probably a
> dodgy entailment, but that doesn't mean it should be considered an
> error by the rules engine.

Well, but now I have to put on my semantics-maven hat. That word  
"entailment" has a particular meaning: A entails B when for every  
legal interpretation I, if A has the value 'true' in I, then so does  
B. That is, entailment is any inference that is guaranteed to preserve  
truth. Now, if something is meaningless, then its not true. So the  
inference of a meaningless B from a is *always* invalid (unless A is  
never true, ie a contradiction - a possibility that we can leave aside  
in this context.) So by declaring some syntactic forms to be required  
to be meaningless, we have broken any inference chains which use those  
forms: such chains can never be classed as entailments, even though  
the entailment of C for A may be perfectly OK.

In fact, disallowing literals as subjects produces exactly this kind  
of 'missing link' problem, where (what would be a) valid inference is  
blocked because it would have to go through an intermediate form which  
is disallowed. I know you do not propose to make these forms  
syntactically illegal, but the problem arises just as sharply if you  
override the natural model-theoretic rules by imposing an 'alien'  
interpretative value on them. The machinery of logic is simple, but it  
does have its own internal, um, logic, and it all kind of hangs  
together, and it gets broken by putting unnatural restrictions on it.
>
> What could { <#Alice> "56.2"^^xsd:decimal <#Bob> . } possibly mean?
> If we assume the class of numbers and the class of relationships is
> disjoint [1]

But RDF does NOT make this assumption. Nor, IMO, should it. Anything  
can be (more properly, can be interpreted to be) a relationship, in  
the RDF model theory. This simplest-possible assumption has proven to  
be extremely robust and extremely useful, and is used in the RDF and  
OWL-Full and ISO Common Logic semantics. It is, I suggest, a mistake  
to mess with it without a VERY good reason. Preserving old logical  
constraints is one quite good reason, given the utility of preserving  
legacy systems. Imposing it because one can't think of a reason not  
to, is not a good reason.

> , then "56.2"^^xsd:decimal cannot be a relationship. If the
> triple doesn't contain a relationship between a subject and an object,
> but Concepts says that all RDF triples do. So a triple with an
> xsd:decimal predicate makes no sense according to Concepts.

Sure it does, if you read the semantics properly. See above.

>
> So my point in saying that literals should be allowed as predicates  
> but
> considered meaningless is to reconcile an arguably desirable feature
> (the simplicity of allowing any node type to occupy any position in a
> triple/quad) with an inescapable fact (that a triple with a literal
> for a predicate doesn't make any sense).

But they can make sense, and indeed they have use cases. Pretty far  
out use cases, but uses nonetheless.

> The pragmatic solution is to
> just say, they're allowed -- tools can operate on them as normal --  
> but
> should have no meaning to humans.
>
> In much the same way as { <#Alice> <#xyzzy> <#Bob> . } has no meaning
> until we have additional information about <#xyzzy>.
>
> I'll add that it has been mentioned that one could mint a datatype URI
> for relationships (e.g. ^^rdf:relationship). As a datatype is
> essentially a mapping from strings to things, this would allow for the
> creation of literals that represent relationships. In this case, I'd
> concede that a triple with one of these datatyped literals as a
> predicate would be meaningful. However, this does seem to be a bit of
> a pathological edge case.

The RDF semantics has had this mapping since day one, its the  
composition of the mapping called IEXT with an intepretation mapping.

Pat

>
> -- 
> Toby A Inkster
> <mailto:mail@tobyinkster.co.uk>
> <http://tobyinkster.co.uk>
>
>

------------------------------------------------------------
IHMC                                     (850)434 8903 or (650)494 3973
40 South Alcaniz St.           (850)202 4416   office
Pensacola                            (850)202 4440   fax
FL 32502                              (850)291 0667   mobile
phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes

Received on Thursday, 8 July 2010 22:57:29 UTC