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

RE: Some advice on inferring negated properties

From: Swanson, Tim <tim.swanson@semanticarts.com>
Date: Thu, 16 Aug 2007 13:20:14 -0600
Message-ID: <51F1B258494D5A4488C95F40E55F35D53E6385@exchsrvr.semanticarts.local>
To: "Bijan Parsia" <bparsia@cs.man.ac.uk>
Cc: "Owl Dev" <public-owl-dev@w3.org>


Thanks for the reply. I found it enlightening to say the least. I
haven't kept up to date on the developing features of OWL 1.1. We
probably won't use it in-house until it reaches the recommendation
stage. However, I do follow the discussions on this list, and feel that
the standard will be good. It already incorporates a lot of the problems
that we've encountered trying to data model using OWL.

> -----Original Message-----
> From: Bijan Parsia [mailto:bparsia@cs.man.ac.uk]
> Sent: Thursday, August 16, 2007 12:49 PM
> To: Swanson, Tim
> Cc: Owl Dev
> Subject: Re: Some advice on inferring negated properties
> On Aug 16, 2007, at 7:16 PM, Swanson, Tim wrote:
> > Am I missing something here?
> I think so.
> > It seems to me that, in order to say that the property assertion (a
> > P b) does not hold, you can say this:
> >
> > <owl:Thing rdf:about="#a">
> >   <rdf:type>
> >     <owl:Class>
> >       <owl:complementOf>
> >         <owl:Restriction>
> >           <owl:onProperty rdf:resource="#P"/>
> >           <owl:hasValue rdf:resource="#b"/>
> >         </owl:Restriction>
> >       </owl:complementOf>
> >     </owl:Class>
> >   </rdf:type>
> > </owl:Thing>
> That's one way. (OWL 1.1 lets you do others.) I mentioned it in my
> email:
> 	"""ClassAssertion(a, ObjectComplementOf (ObjectHasValue(P,
> b)))""""

This was an addition I wasn't aware of.

>From a modeling standpoint, ObjectComplementOf is great. While you can
imitate it, it requires brute force and/or preprocessing in all but the
most trivial cases (such as the one outlined above).

Is a complement property a full-fledged property (as an object class is
a full-fledged class)? Can you add subproperties to it, for instance?
This would result in a much richer property model and, as an ardent OWA
fan, would all by itself make OWL 1.1 worth the price of admission in my

> > Although this seems verbose (especially in RDF/XML), it's really
> > just saying that 'a' is not a member of the set of things that have
> > the property 'P' with the filler 'b'.
> >
> > An approach like the one Bijan suggested:
> >
> >>> 	ClassAssertion(a, ObjectMaxCardinality(0, P, owl:Thing))
> >>> 	ClassAssertion(b, owl:Thing)
> >
> > Is making the more general assertion that a cannot have /any/
> > instances of property P.
> Yep. But please recognize that I used that as an example of how to
> *entail* a negated property assertion. I wanted to have an example
> where you weren't just paraphrasing the assertion you were looking

I see, *entail* as opposed to *assert*.

> > The approach I've outlined above seems to make the assertion that a
> > specific property relationship is negated, and nothing else.
> That works. In OWL 1.1 you can say it directly to, i.e.,:
> 	NegativeObjectPropertyAssertion(P, a, b)
That's great. Syntactic sugar for the above, and a direct
acknowledgement of OWL's OWA origins.

> (It's a a bit less pleasant in RDF/XML as you have to reify...here's
> hoping for better solutions. The abstract syntax and the XML syntax
> aren't so bad.

I've noticed a tendency in the hardcore OWL/RDF community to focus on
both OWL and RDF as abstract data models, and to view the output as a
low-level representation that's only of interest to machines. (The
debate on this list over using tools vs. text editors in relation to
"declaredAs" underscores this point.) While this is technically correct,
it is not the whole story.

We use RDF/OWL as a messaging format in distributed systems. As such, we
use the RDF/XML format exclusively. (This is why I gave my example above
in that format; it's only one I have a confident competence with.) While
the messages are certainly generated and consumed by machines,
developers need to be able to look at them during testing and debugging.
In a development environment, it is often helpful to be able to not only
read, but also write, small snippets of RDF/OWL. A readable syntax is a
must in this case. (Note that it does not need to be intuitive, merely
readable and learnable.)

Obviously, things like serialization are best tackled /after/ the
abstract syntax is finalized, but as you go forward, I implore to not to
ignore issues like readable serialization. (For the record, I like
RDF/XML just fine except for rdf:ID, and the OWL 1.0 RDF serialization
is pretty good too.)

> Also, the nominal form, well, requires nominals. Not all reasoners
> support them. A perhaps more flexible encoding in OWL 1.1 would be to
> use a dummy class and a qualified number restriction to 0 Ps to that
> class.)
> > We've used this in our applications, so I'd like to know if we have
> > an incorrect understanding.
> Only of my email, I think.
> Hope this helps.
> Cheers,
> Bijan.

I've seen a lot of teeth gnashing, hair pulling sort of discussions on
this list, and I thought it may help to know that there are those of us
out there who are fans of your collective work and are eagerly awaiting
the completed standard.

Keep up the good work,

Tim Swanson
Semantic Arts, Inc.
Fort Collins, Colorado
Received on Thursday, 16 August 2007 19:17:44 UTC

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