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

Re: [OWLWG-COMMENT] Punning and the "properties for classes" use case

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Fri, 02 Nov 2007 09:20:46 -0400 (EDT)
Message-Id: <20071102.092046.90784564.pfps@research.bell-labs.com>
To: schneid@fzi.de
Cc: public-owl-dev@w3.org

From: "Michael Schneider" <schneid@fzi.de>
Subject: [OWLWG-COMMENT] Punning and the "properties for classes" use case 
Date: Thu, 1 Nov 2007 16:38:20 +0100

> 
> [Public comment to public-owl-wg discussion; CC'ing to involved WG members] 
> 
> Foreword: Until now, I have found very few information about punning, and I
> do not remember any serious discussion about punning in this mailing list
> (just a few remarks here and there by different people). So I will just use
> this opportunity to start such a discussion. It might well be that, due to
> my missing knowledge about punning, I am wrong in several points I am
> stating in this mail. But I believe that it is better to state wrong points,
> which will then hopefully get corrected within the following discussion,
> instead of having no public discussion at all.
> 
> Summary:
> 
> This week, Jeremy Carroll discusses punning in the OWL-WG mailing list in:
> 
>   "comments on RDF mapping"
>   http://lists.w3.org/Archives/Public/public-owl-wg/2007Oct/0336.html
>   http://lists.w3.org/Archives/Public/public-owl-wg/2007Oct/0337.html
> 
> His observation is that certain OWL-Full entailments do not exist with
> punning. For instance:
> 
>   """
>     <a> rdf:type owl:Thing .
>     <a> rdf:type owl:Class .
>     <b> rdf:type owl:Thing .
>     <b> rdf:type owl:Class .
>     <a> owl:sameAs <b> .
> 
>   entails [in OWL Full]
> 
>     <a> owl:equivalentClass <b> .
>   """
> 
> But, according to Jeremy, the latter statement is /not/ entailed in
> OWL-1.1(-DL) with punning.

Well, in OWL 1.1, it is true that 

	Declaration(Individual(a))
	Declaration(OWLClass(a))
	Declaration(Individual(b))
	Declaration(OWLClass(b))
	SameIndividual(a b)

does not entail

	EquivalentClasses(a b)

Neither does 
	
	SameIndividual(a b)

entail

	EquivalentClasses(a b)

in OWL DL.


> I am going to comment on Alan Ruttenberg's answer to Jeremy's mails.
> 
> 
> Alan Ruttenberg wrote on 30 Oct 2007 in
> http://lists.w3.org/Archives/Public/public-owl-wg/2007Oct/0353.html
> 
> >My understanding is that there is a requirement to be able to create  
> >properties attached to classes that have more inference support than  
> >is currently possible using annotation properties. For example, it is  
> >desirable that an "annotation property" for an editing time stamp  
> >should have a range that is xsd:date, or, for SKOS, we would like  to  
> >be create subproperties of rdfs:label.
> 
> I agree that this would be a very valuable feature. But I don't believe that
> this feature is really provided by punning.
> 
> >Alan Rector articulated these cases initially, IIRC. I suspect they  
> >are recorded somewhere amongst  the OWLED stuff.
> >
> >I believe that you have correctly identified the missing entailments.  
> >Those entailments, while desirable in general, are not necessary for  
> >the above use case. 
> 
> I think that this argumentation might be somewhat shortsighted. Let's regard
> for example the following situation:
> 
>   (1) <c1> a owl:Class .
>   (2) <p> a owl:ObjectProperty .
>   (3) <c1> <p> <x> .

In OWL 1.1

	Declaration(OWLClass(c1))
	Declaration(ObjectProperty(p))
	ObjectPropertyAssertion(p c1 x)

which should also have

	Declaration(Individual(c1))
	Declaration(Individual(x))

> While OWL-1.0-DL will not allow this combination of axioms, 

Not true,

	Class(c1)
	ObjectProperty(p)
	Individual(c1 value(p x))

is valid OWL DL abstract syntax.  (It is true that the RDF translation
for this OWL DL KB is not defined.)

> it actually is
> allowed with punning. So it looks like as if I really have achieved to add
> an objectproperty to some class.

Huh?  The above treats p as a property/predicate throughout.

> Now, it will probably be quite common in the SemWeb to make further
> assertions about a class by using a /different/ name for it, and OWL with
> punning allowes us to do so by stating an additional renaming axiom like:
> 
>   (4) <c2> owl:sameAs <c1> .

In OWL 1.1

	SameIndividual(c2 c1)

> Having axioms (1) to (4), a punning enabled reasoner will be able to infer
> the following new statement:
> 
>   (5) <c2> <p> <x> .

In OWL 1.1

	ObjectPropertyAssertion(p c2 x)

Yes, as this is just individual reasoning.

> So up to now, everything looks fine with regards to the "properties for
> classes" use case. 
> 
> But it doesn't might look so fine anymore, if we have additional axioms on
> class <c1>. Say, we have the assertion:
> 
>   (6) <i> a <c1> .

In OWL 1.1

	ClassAssertion(i c1)

> and I want to make <c1> into a sub class of another class <d>, but now by
> using its alleged synonym "<c2>":
> 
>   (7) <c2> rdfs:subClassOf <d> .

In OWL 1.1

	SubClassOf(c2 d)

> then I would expect that the following statement can also be inferred:
> 
>   (8) <i> a <d> .

In OWL 1.1

	ClassAssertion(i d)

which doesn't follow.

> But as far as /I/ understand punning, (8) won't be entailable, because the
> URI called "<c1>" denotes a class in (1), while it denotes an individual in
> (3). 

Yes, in effect.

> In effect, I did not, as intended, assign property <p> to the class
> ressource denoted by the name "<c1>", but instead, this property has been
> assigned to some possibly completely different individual resource, which
> just happens to have the same name. 

You don't have to think of the situation this way.  Instead it is
possible to think of a name denoting a resource that has several
different components, including an individual entity and a class entity.

> And there has to be no semantical
> relationship between these two resources, so these two resources don't have
> to coincide, see section 3.3 of [1].

And you get to this same place, more or less.

> I can at least see in the semantics draft [2] that in OWL-1.1 there will be
> no strict separation of the different parts of the OWL universe
> (individuals, classes, etc.) anymore, as it has been originally demanded for
> OWL-1.0-DL. 

I'm not sure what you mean here.  You could either be alluding to the
separation of the RDF universe into different categories in the
secondary RDFS-compatible model theory for OWL DL or to the namespace
separation needed for the translation from the OWL DL abstract syntax
into RDF syntax.  Both of these have to do with the relationship between
OWL DL and RDF, which is not the subject of either they syntax draft or
the semantics draft.

> But this makes it only /possible/ for an individual and a class
> to be the same. As long as I do not have any means in OWL-1.1-DL to also
> /enforce/ these two resources to be the same, this relaxation seems to be
> useless to me with respect to punning. (BTW: I am not certain whether this
> relaxation is a good idea, but this is another topic.) 

I'm not sure what you are getting at here.  It is definitely the case
that punning is very weak.  This is by design.  In fact, you could
always rename apart names that are punned.

> Punning, as I understand it from [1], is just a means for "overloading"
> names for resources from different parts of the OWL universe. Without
> punning, I would have to write axioms (1) and (3) above in a form like
> 
>   (1') <c1_class> a owl:Class .
>   (3') <c1_indiv> a owl:Thing .

Precisely.

> In OWL-DL plus punning, the reasoner will have to do such URI renamings
> itself in a pre-processing step before it can start its reasoning tasks.
> This seems necessary, otherwise the reasoner might produce wrong
> entailments. 

Nope.  The reasoner doesn't have to do this.  There are lots of ways to
separate the use of a name as a class versus its use as an individual.
This has to be done even in RDFS reasoners, otherwise you might have 
	c1 p x .
affect the property/class extension of c1.

> >As I understand it, the reason those entailments  
> >are not supported is that there is not enough theoretical work to  
> >ensure that they can be implemented in a sound, complete, and  
> >decidable manner.
> >
> >Proponents of punning would label this:
> >
> >"OWL DL, now with more, but not all, of OWL Full goodness"
> 
> As I understand it, punning has nothing to do with OWL Full semantics, and
> then it would not provide any kind of "OWL Full goodness". 

Say instead that it allows saying *some* of the things that can be said
in OWL Full.

> I rather believe
> that the proponents of punning think that overloading URIs in OWL might be
> useful, or at least convenient, in certain cases. I could imagine that the
> argumentation might go this way:
> 
>   "In OWL-1.0-DL, one workaround to assign properties 
>   to a class C is to dedicate some individual iC, which
>   receives the property as a proxy for C. So why not just 
>   give this proxy individual the same name as the class
>   to make the intended connection between them both more 
>   explicit?"

Sure, this sounds quite reasonable.

> But I find it pretty confusing to overload URIs, to say the least. 

Well, RDF overloads URIs already.  A URI in RDF denotes a entity in the
domain of discourse as well as that entity's property extension, which
also carries the entity's class extension.

> As my
> example above demonstrates, it is very easy to draw wrong conclusions about
> the semantics of an ontology when using URI overloading (confusing for a
> human, who constructs and/or reads ontologies; not confusing for a machine,
> of course). 

In a lot of ways this comes from looking at OWL DL / OWL 1.1 through an
RDF(S) lens.  Viewed in their natural state punning doesn't look nearly
as confusing.

> So I consider punning, while perhaps a "nice-to-have" feature,
> to be a very dangerous feature in practice, and I will prefer to follow the
> saver principle: "One URI, one resource". 

Yes, well, then how do you handle 

	ex:a owl:sameAs ex:b .

Here we have two URIs, but only one resource 

> Anyway, if my argumentation above is right, then punning does not cover the
> "properties for classes" use case.

Could you provide a pointer to this use case?


> Cheers,
> Michael
> 
> [1] "Next Steps for OWL"
>     http://owl-workshop.man.ac.uk/acceptedLong/submission_11.pdf 
> 
> [2] "OWL 1.1 Model-Theoretic Semantics", chapter 2
>     http://www.webont.org/owl/1.1/semantics.html#2
> 
> 
> --
> 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

Peter F. Patel-Schneider
Bell Labs Research
Received on Friday, 2 November 2007 13:31:16 GMT

This archive was generated by hypermail 2.3.1 : Wednesday, 27 March 2013 09:32:55 GMT