Re: RDF Extensibility

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. 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.

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], 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.

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). 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.

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

Received on Thursday, 8 July 2010 19:29:31 UTC