W3C home > Mailing lists > Public > public-owl-dev@w3.org > October to December 2007

[OWLWG-COMMENT] Re: Cardinality Restrictions and Punning

From: Pat Hayes <phayes@ihmc.us>
Date: Fri, 21 Dec 2007 11:47:48 -0800
Message-Id: <p06230909c391c30b106a@[]>
To: "Michael Schneider" <schneid@fzi.de>
Cc: "Jeremy Carroll" <jjc@hpl.hp.com>, "Owl Dev" <public-owl-dev@w3.org>

>[public comment to OWL-1.1 WG discussion]
>Hi Jeremy!
>Jeremy Carroll wrote on Thu, 20 Dec 2007
>in <http://lists.w3.org/Archives/Public/public-owl-wg/2007Dec/0239.html>:
>>  Hmmm, this is tricky, harder than I thought.
>>  Some examples. I'm struggling as to the discussion.
>>  Example 1:
>>  Consistent:
>>  [punning on eg:p]
>>  eg:a rdf:type owl:Thing .
>>  eg:a eg:p   eg:a .
>>  eg:p rdf:type owl:ObjectProperty .
>>  eg:p rdf:type owl:DataProperty .
>>  _:r rdf:type owl:DataRestriction .
>>  _:r owl:maxCardinality "0"^^xsd:int .
>>  _:r owl:onProperty eg:p .
>>  eg:a rdf:type _:r .
>While you do not explain what your mail is about, I believe that you are
>searching for an example which shows problems or dangers resulting from the
>interplay between data/object property punning, cardinality restrictions,
>and OWL-DL vs. OWL-Full semantics. Is it this what you are looking for?
>If yes, then the following example RDF graph {(R1*)} might be of interest to
>you, because it is a consistent ontology in OWL-1.1-DL, but it is
>*inconsistent* in OWL-1.0-Full.
>Of course, the RDF compatible semantics for OWL-1.1 will have to be
>constructed in a way that the graph {(R1*)} becomes consistent.

I don't agree. One should expect that the Full semantics will support 
more entailments than the DL semantics does, since the Full version 
is obviously a more expressive language than the DL. A special case 
of this is exactly the situation you describe, where an ontology 
which is consistent in DL is inconsistent in Full. I would be more 
worried if you could find an example the other way round.

>Otherwise I
>would not be willing to say that OWL-1.1-Full is in any way "compatible"
>with OWL-1.1-DL.

I would expect that xx-Full is a more powerful (expressive, whatever) 
language than xx-DL, so any xx-DL entailments are also xx-Full 
entailments,but not necessarily the other way around. And this might 
apply even on sentences which are syntactically in the xx-DL subset. 
In other words, the relationship between OWL-Full and OWL-DL is 
somewhat like that between OWL-DL and RDFS, and between RDFS and RDF.

>Whether and how this can be achieved will be an interesting
>Here is the example graph, which is just a slightly modified version of your
>"Example 1" above:
>   (R11) eg:a rdf:type owl:Thing .
>   (R12) eg:b rdf:type owl:Thing .
>   (R13) eg:a eg:p eg:b .
>   (R14) eg:p rdf:type owl:ObjectProperty .
>   (R15) eg:p rdf:type owl:DataProperty .
>   (R16) _:r rdf:type owl:DataRestriction .
>   (R17) _:r owl:maxCardinality "0"^^xsd:int .
>   (R18) _:r owl:onProperty eg:p .
>   (R19) eg:a rdf:type _:r .
>The differences are that we now have an additional individual 'eg:b' defined
>in (R12), and (R13) is not a loop triple anymore.
>This graph can be translated into the following Functional Syntax ontology:
>   (F11) Declaration(Individual(eg:a))
>   (F12) Declaration(Individual(eg:b))
>   (F13) ObjectPropertyAssertion(eg:p eg:a eg:b)
>   (F14) Declaration(ObjectProperty(eg:p))
>   (F15) Declaration(DataProperty(eg:p))
>   (F16) ClassAssertion(eg:a DataMaxCardinality(0 eg:p))
>>From this one can see that the ontology is *consistent* w.r.t. OWL-1.1-DL
>semantics including property punning. This is the case, because (F13) refers
>to to eg:b as an /Individual/, so eg:p is an /Object/Property in (F13). But
>the cardinality restriction in (F16) refers to eg:p as a /Data/Property,
>which may be different from the ObjectProperty eg:p.

Dear god. Punning is supposed to be MORE intuitive than RDF-style 
semantics?? Seems to me that this obviously, on its face, should be 
inconsistent, and any semantics that fails to make it so is seriously 
broken. After all, the object/data distinction has no SEMANTIC 
justification at all. It was introduced solely to make the DL 
reasoners work faster. To take a premature optimization hack like 
this and warp the basic semantics to fit it, sacrificing even common 
sense along the way, seems to me like the worst of the worst in 
semantic engineering.

If the language must support the data/object distinction - and I 
suppose there is no way at this stage to go back on that particular 
bad decision - then it would be better all round, I suggest, to 
simply forbid property punning between the two categories. Punning is 
a hack, but punning between classes and individuals and even between 
properties and individuals is workable for the same reason that the 
hilog semantics is workable: the immediate syntactic context 
disambiguates the intended meaning for every occurrence of the name. 
However, the object/data distinction is quite different: it amounts 
to a sort distinction in FOL. To allow punning between different 
sorts, as opposed to different logical/lexical categories, is 
shooting oneself in the foot, as the whole point of sorts in a logic 
is that the immediate syntactic context does NOT disambiguate them 
(which if you think about it is why they are so useful, most of the 
time), so there is no clear way to keep track of the consequences of 
the punning. All these examples attest to this, in fact.

This is the first I have heard of 'property punning'. Is there a 
compelling use case for it? If not, I suggest dropping the idea.



IHMC		(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.	(850)202 4416   office
Pensacola			(850)202 4440   fax
FL 32502			(850)291 0667    cell
phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes
Received on Friday, 21 December 2007 19:48:07 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:58:16 UTC