W3C home > Mailing lists > Public > public-owl-dev@w3.org > January to March 2008

RE: [OWLWG-COMMENT] Re: Cardinality Restrictions and Punning

From: Michael Schneider <schneid@fzi.de>
Date: Sat, 5 Jan 2008 20:05:59 +0100
Message-ID: <0EF30CAA69519C4CB91D01481AEA06A05A6131@judith.fzi.de>
To: "Evren Sirin" <evren@clarkparsia.com>
Cc: "Owl Dev" <public-owl-dev@w3.org>

Hi, Evren!

Evren Sirin wrote on Friday, January 04:

>On 1/4/08 7:42 AM, Michael Schneider wrote:
>> But I now see that I can get the same effect even much easier:
>>    (A1') <C> a owl:Thing
>>    (A2') <D> a owl:Thing
>>    (A3') <C> owl:sameAs <D>
>>    (A4') <C> a owl:Class
>>    (A5') <D> a owl:Class
>>    (A6') <C> owl:ComplementOf <D>
>> Now, in Full follows from (A3')
>>    (E1') <C> owl:equivalentClass <D>
>> Thus, by (E1') and (A6'), the new ontology is 
>Full-*inconsistent*. But
>> because (E1') doesn't follow in DL+Pun (punning is too weak 
>for this), this
>> ontology is DL+Pun-*consistent*. 
>> Oh dear, this ontology is so simple! One could even savely 
>remove all the
>> typing axioms, leaving just the two triples (A3') and (A6'). 
>I really should
>> have found this example immediately, how embarrassing! :)
>Don't be so hard on yourself because you found this example beore you 
>just forgot about it :) 


>This was the underlying problem you 
>mentioned in 
>[1] that owl:sameAs has weaker semantics under punning. 

Actually, I really remembered this. But at that time I wasn't searching for
an DL-consistent/Full-inconsistent ontology, and now I did not immediatly
come to the simple idea of just combining a 'sameAs' axiom with an explicit
'complementOf' axiom. For my first, still unnecessarily complex example in
my previous mail to Pat, I probably searched for about an hour or so - and
believed most of the time that it wasn't possible at all. This is what I
meant by "embarrassing". :)

>This is a 
>well-known issue that was pointed out by other people in this mailing 
>list (e.g. see [2]).

Ah, this mail was really unknown to me. (Strange, since I took part in this
thread, but probably was only interested in the "declaration" issue then.)
The discussion between Bijan and David Turner, which followed this mail, may
be of value for my understanding of punning (in particular for my
understanding of the arguments /pro/ punning), so I am going to have a
closer look at it. Thanks for the link!
>Not everybody agrees this is a major 
>problem and I 
>tried to explain my point-of-view in the previous thread [3].

I see that I did not answer to all the statements you made in your mail, so
we can catch up on these points, if you like.

You wrote on 03 Nov 2007:

> On 11/2/07 3:23 PM, Michael Schneider wrote:
>> Hi, Evren!
>> Evren Sirin wrote on November 02, 2007:
>>> Michael,
>>> You are correct in your understanding of punning. It is true that 
>>> punning semantics is strictly weaker than OWL-Full semantics and the 
>>> inferences you will get will be a subset of OWL Full entailments. 

Is this a certain fact? I remember to have heard this claim a few times
before now, but don't remember to have ever heard about evidence for it.
Since there is no 1.1-Full draft at the moment, is there some proof that
this would be true for 1.0-DL+Punning in comparison to 1.0-Full?

>>> But 
>>> what is the alternative? Without punning, any ontology where 
>>> classes are 
>>> used as instances will not be allowed in OWL-DL and rejected by OWL-DL 
>>> reasoners. So you have to use an OWL-Full reasoner which means you are 
>>> stuck with incompleteness (I'm not aware of any OWL-Full reasoner) 

I recently found that the Jena-OWL reasoner is actually a restricted
OWL-Full reasoner, since it is an extension of the Jena-RDFS reasoner:


  "Since RDFS is not a subset of the OWL/Lite or OWL/DL languages 
  the Jena implementation is an incomplete implementation of OWL/full."  

Drawback: It doesn't fully support every OWL feature. But this has not to do
with being an OWL-Full reasoner, but instead, AFAIK, has to do with the
specific rule based approach the family of Jena reasoners apply. 

Nevertheless, I can imagine that the Jena-OWL reasoner might be sufficient
for certain real world OWL-Full ontologies, which use metamodelling, even if
this is known to be undecidable in the general (theoretical) case. One would
have to experiment with the combination of such an ontology and the Jena
reasoner, of course, in order to see whether it works the expected way for
one's usecases. 

But this is not really different from the case of using an OWL-DL reasoner
for an OWL-DL ontology. Applied naively, the fact that OWL-DL is a decidable
language doesn't necessarily save me from loooong waits for reasoning
results, garnished with stack overflows and out-of-memory errors. In
practice, I wouldn't categorically regard the NExpTime-completeness of
OWL-DL to be a real advantage over the undecidability of OWL-Full.

>>> depending on which OWL-Full reasoner you use incompleteness come from 
>>> different parts (e.g. some reasoners doesn't support 
>>> owl:sameValuesFrom, 
>>> others don't support owl:oneOf, etc.). At least with punning you know 
>>> what causes the incompleteness. 
>> If metamodelling brings us away from decidability 
> No, not at all. You are confusing decidability and completeness.

For my understanding: Can you please explain to me how you use the term
"completeness" here. I know at least two different definitions of this term,
so I want to make sure that I correctly understand your arguments below. 
> Metamodeling provided by punning does not cause undecidability.

I did not regard individual/class punning to be a form of metamodelling at
that time. And I do not regard it as such today, because, according to my
understanding, metamodelling would require that in

  <x> rdf:type <y>
  <y> rdf:type <z>

the two occurrences of '<y>' always denote the same entity in the universe,
w.r.t. every possible interpretation. This is not necessarily the case with
punning, which allows cases where the two occurrences of '<y>' may denote
"semantically unrelated" entities. In particular, if the OWL universe
happens to be separated (i.e. 'owl:Thing' and 'owl:Class' denote disjoint
parts of the OWL universe), then these two occurrences of '<y>' will /never/
denote the same entity. That's why, when someone calls punning
"metamodelling", I call calling it so... "punning". ;-)

So my discussion in my former mail was more of the kind: If metamodelling
(with identical(!) entities, as described above) is undecidable in OWL (it
is!), then it should not be tried to use punning as a "weak" substitute for
metamodelling. Instead, one should either drop the wish for metamodelling
capabilities completely (that's the status quo in OWL-1.0), or include some
form of "real" metamodelling, and drop instead the demand for decidability
(only an option for post-OWL-1.1 WGs, of course). 

Whether the latter is a solution which really works in practice would need
research, of course. But OWL-1.1 is certainly not the last version of OWL,
so I do not see any need to rush the introduction of metamodelling
capabilities into OWL-DL. I really would suggest to POSTPONE the
metamodelling issue now, and first try to rapidly finalize all those other
very useful proposed new features of the OWL-1.1 draft, which are much less

> Metamodeling features of OWL-Full, however, makes OWL-Full undecidable. 
> There are other reasons for OWL-Full's undecidability (e.g. cardinality 
> restrictions on transitive properties) but OWL-Full metamodeling itself 
> is undecidable. See Motik et al'.s paper [1] on the subject.

I had read Boris' paper in the past, and so already knew at that time that
Full-metamodelling is undecidable. 

Btw, as an annecdote (it's weekend, after all :)), this paper actually was
the first time I came in touch with OWL-Full semantics. And I received the
citation to this paper in my very first discussion in one of the W3C SemWeb


After reading Boris' (great!) proof there, I found OWL-Full so crazy that I
did not want to deal with it ever again. :)

> On the other hand, you can have sound and complete reasoners for an 
> undecidable logic (there are many for FOL) but there does not exist a 
> complete reasoner for OWL-Full. The point I was trying to make was, with 
> the current definition of OWL-DL and OWL-Full, using any kind of 
> metamodeling features puts you in OWL-Full species for which there is no 
> complete reasoner. By relaxing the restrictions on OWL-DL we get a 
> decidable language for which there are many sound and complete (w.r.t. 
> OWL-DL semantic) reasoners. On the down side, the inferences produced by 
> these reasoners will not be complete w.r.t. OWL-Full semantics but this, 
> in my opinion, is not such a high price to pay.

Ok, I won't spend any effort in trying to understand the above paragraph
until you explained to me the term "completeness". :)

>> (this is the real problem,
>> right?), then I see two alternatives:
>>   (1) Stop hunting for metamodelling capabilities in OWL-1.1-DL.
>>       Metamodelling, even in a restricted form, would really be 
>>       a useful feature, but the community has already learnt 
>>       to live with the current situation.
> No, not really. The workarounds for vocabulary separation is ugly and 
> cumbersome. I will give you one example related to OWL-S effort [2] but 
> there are other similar use cases. OWL-S coalition worked hard to keep 
> OWL-S ontologies in the DL species to make it accessible to OWL-DL 
> reasoners. This meant to create a shadow list for rdf:List vocabulary 
> quoting URI's and RDF/XML snippets as literal values, etc. This rather 
> ugly solution created many problems for developers (e.g. me as the 
> developer of OWL-S API [3]) and users of OWL-S (see [4] about one 
> example problema). With the use of punning all these troubles go away. 
> And the incompleteness regarding sameAs-equivalentClass has no 
> importance in this setting.

This seems to be the same topic about which you talk in


But I do not understand how punning can be used to solve the problem here.
Can you please give a sketch on the idea? Only then I can check myself
wheter the "same-iff" entailment is not relevant for this usecase.

>>   (2) Add general metamodelling (not necessarily complete OWL-Full
>>       to OWL-1.1-DL, and remove the requirement for decidability.
>> My personal preference would be to go the (1)-way for OWL-1.1-DL, as a
>> save and conservative solution. And then (later) start thinking about an
>> additional language somewhere in the middle between OWL-1.1-DL and
>> OWL-1.1-Full, which I would call "OWL-UseFull". ;-) This language would
>> a few additional most-wanted features (like metamodelling), but it does
>> allow you to build any of those scary (and useless) constructs, which you
>> can actually build in OWL-Full.
>> A caveat would be that decidability could then not be a requirement
>> But I would not stop thinking about this proposal from the start on. One
>> would have to determine if this brings real problems in /practice/. In
>> there is a lot of useful software around for undecidable problems,
>> getting into practical problems, as long as this software is used in a
>> meaningful way (parser generators, type checkers for the Haskell
>> automatic reasoners for FOL and HOL, computer algebra systems).
>>> I might be wrong but I'm not aware of 
>>> anything other than sameAs-equivalentClass (and possibly 
>>> equivalentProperty) relation that would cause the punning semantics 
>>> incomplete w.r.t OWL-Full semantics.
>> I think this alone already suffices, no need to look for more. :)
> I disagree. Punning solves the problems in the above use case and the 
> sameAs-equivalentClass distinction has no impact. There were other 
> similar use cases discussed at OWLED from different domains where 
> punning would be sufficient.

I will have to wait for your explanation on the 'list' usecase. You are of
course invited to tell me about additional usecases, too. :) 

I want to say that I am surprised that usecases exist where the
"same->equivalent" entailment "has no impact". But I also have to admit that
until now I did not thought in terms of usecases for this entailment. I
always thought about it to be "self-evident" that this entailment has to
exist. And there might be a large gap between "it's evident" and "it's
needed/useful". I will have to think about this a little more.

>>> I'd be interested in seeing if 
>>> there is any other use case where punning semantics does not entail 
>>> everything OWL-Full semantics does.
>>> FWIW, punning has been implemented in Pellet for years and I don't 
>>> remember any of our users calling it "confusing" or "useless".
>> That's interesting to hear, I did not know this. But has this also been a
>> feature in Pellet which has been /applied/ by /many/ users for years? 
>>> I believe 
>>> it is more of a personal style choice to use punning (it might be 
>>> confusing for some people but not others). I think it is a 
>>> viable option 
>>> for "properties for classes" use case (though I'd personally call it 
>>> classes as instances use case)
>> Yes, better. And in fact, the property discussion in my mail was a little
>> bit redundant. Though my intended message was in effect that with punning
>> is easy to believe that one can assign a property to a class, while one
>> actually assigns it to some equally named, but possibly completely
>> individual resource. Now, after Alan's answer, I am not certain anymore,
>> it is still possible that an individual can be different from an
>> equally-named class. This is a core question to me.
> Sorry, I'm not sure I understand the problem here. 
> I thought the problem 
> you are pointing out is that the axioms you list as
> (4) <c2> owl:sameAs <c1> .
> (6) <i> a <c1> .
> (7) <c2> rdfs:subClassOf <d> .
> does not entail
> (8) <i> a <d> .
> which is exactly the same thing mentioned in the "Next steps for OWL" 
> paper you cited (see the example at the end of page 3).

Oops, I must have read this paper very selectively, because, while I cited
from it several statements, I did not found (or at least: did not remember)
this example there. :)

Anyway, to answer your question, what I was about with my statement above
was the following: In the "Next steps" paper, the IMO most interesting
statement about punning was that when, for example, the same name 'n'
denotes both an individual and a class, then these two entities do not have
to be semantically related in any way. Or as an example: A given
interpretation of an ontology using punning may denote the one occurrence of
'n' by an individual car, and the other occurrence of 'n' by the set of male
people. So in general, even if it is theoretically possible that the two
occurrences may denote the same entity, one cannot expect them to conincide
in general, since there is no means to enforce the two denoted entities to
be the same. And, of course, the two entities can only coincide in the case
of a non-separated OWL universe. 

This has been my understanding of punning at that time, and it was the
reason why I called punning an "overloading mechanism". But Alan came up
with a different understanding of punning, which was new to me:

  Alan Ruttenberg on Thu, 1 Nov 2007 in
  >However the intention is not that there is  
  >no "semantical relationship"  between them. In discussion on this  
  >topic it has been proposed that we make it clear that these are  
  >intended to be the same entity,  

At least in the case of a separated universe, my and Alan's understanding of
punning aren't compatible. So I was confused what punning was at all. And so
I asked for a clear definition of punning - to be included in the OWL-1.1
draft! I haven't found any definition there, only a single statement that
punning is used in OWL-1.1:


  "Since OWL 1.1 allows punning [Metamodeling] in the signature, [...]"
Having a solid definition of the "punning" feature in the spec is a real

>>> because most of these use cases do not 
>>> depend on sameAs-equivalentClass relation.
>> I think that this relation is so fundamental, that you cannot really
>> to stumble over it ever and ever again. Perhaps, I will come up with
>> examples in the future, which demonstrate the /practical/ problems (but
>> before my headache produced by this topic has gone away again ;-)).
> Hopefully this message won't give you more headaches :)

It certainly did, but don't take it personally! ;-)

> Cheers,
> Evren


> [1] 
> [2] http://www.daml.org/services/owl-s/
> [3] http://www.mindswap.org/2004/owl-s/api/
> [4] http://tech.groups.yahoo.com/group/jena-dev/message/6979

>> Cheers,
>> Michael

Dipl.-Inform. Michael Schneider
FZI Forschungszentrum Informatik Karlsruhe
Abtl. Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: Michael.Schneider@fzi.de
Web  : http://www.fzi.de/ipe/eng/mitarbeiter.php?id=555

FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts
Az: 14-0563.1 Regierungspräsidium Karlsruhe
Vorstand: Rüdiger Dillmann, Michael Flor, Jivka Ovtcharova, Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
Received on Saturday, 5 January 2008 19:06:45 UTC

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