On Jul 8, 2010, at 2:28 PM, Toby Inkster wrote:
On Thu, 8 Jul 2010 12:16:06 -0500
Pat Hayes <pha...@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:m...@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
