W3C home > Mailing lists > Public > public-owl-dev@w3.org > April to June 2010

Re: The notion of a "classification criterion" as a class

From: Bene Rodriguez-Castro <beroca@gmail.com>
Date: Thu, 29 Apr 2010 20:02:10 +0100
Message-ID: <i2jea8cd28f1004291202s57fd1991ufff31ac94faa0460@mail.gmail.com>
To: "[ontolog-forum]" <ontolog-forum@ontolog.cim3.net>, public-owl-dev <public-owl-dev@w3.org>
Cc: doug@foxvog.org, rector@cs.man.ac.uk
Hi Doug,
I found very useful reference [3] from your first reply ( Instances of
Instances Modeled via Higher-Order
Classes<http://www.foxvog.org/doug/higher-order2.pdf>).  I realized I
tend to tangle the concept of instance/individual and
class/meta-class but the definitions in the paper together with the ontology
of levels of meta-classes definitely help to clarify these concepts.
 (Reference [4] in the same email does not seem to be publicly available

Some comments in-line below and some requests for clarification if possible.

On Sun, Apr 25, 2010 at 6:08 AM, doug foxvog <doug@foxvog.org> wrote:

>    Benedicto Rodriguez <br205r@ecs.soton.ac.uk> <br205r@ecs.soton.ac.uk>wrote:
> > :Independent_Entity (aka :Self_Standing_Entity)
> >    |-- :Grape
> >        |-- :WineGrape
> >            |-- :MerlotGrape
> >            |-- :ChardonnayGrape
> ?            |-- (etc...)
> >    |-- :Wine
> >        |-- :MerlotWine
> >        |-- :ChardonnayWine
> >        |-- (etc... meaning rest of "wines by grape")
> >        |-- :RedWine
> >        |-- :RoseWine
> >        |-- (etc... meaning rest of "wines by color"
> >            although in this case, only :WhiteWine is left)
> >        |-- :SpecificMerlotWineClass
> >        |-- :SpecificRedWineClass
> >        |-- :SpecificMerlotAndRedWineClass
> >        |-- :SpecificChardonnayWineClass
> >        |-- :SpecificWhiteWineClass
> >        |-- :SpecificChardonnayAndWhiteWineClass
> >        |-- (etc... meaning rest of "specific" wine classes that
> >             we would need to represent and automatically classify
> >             by the reasoner based on their "grape" and "color")
> > :Dependent_Entity (aka :Refining_Entity)
> >    |-- :Value_Partition
> >        |-- :WineColor
> >            |-- :Red
> >            |-- :Rose
> >            |-- :White
> I question this.  Is WineColor a subclass of Value_Partition, an
> instance of Value_Partition, or something else?  Also, are :Red,
> :Rose, and :White subclasses of :WineColor, instances of :WineColor,
> or do they have some other relationship with :WineColorPartition?
In this example :Red, :Rose and :White are subclasses of :WineColor.
This is modelled following Pattern 2 (variant 2) in the cited W3C note:

The relationship between :Value_Partition and :WineColor is an interesting
point.  It seems to me now, after the comments in this thread, that the
representation of :Value_Partition as a class is controversial for the same
reasons that classes such as :WineByGrape, :WineByColor and in general XbyY
are.  They seem to provide "meta-knowledge".  Knowledge about other classes
in the ontology and that cannot be represented as a "class" using OWL DL
set-based semantics.

And although the Normalization mechanism suggests to include the notion of
value partition (or refiner) as a class in the inheritance structure of the
ontology, I realized Alan Rector already referred to this controversy in the
cited paper. (Section "Issues and Problems" in "Modularisation of domain
ontologies Implemented indescription logics and related formalisms including

> Normally, a partition is an instance that identifies a base class
> and a set of mutually disjoint subclasses which span the base class.
> This is a binary relationship between a class and a set of classes.
> OWL-DL disallows the first argument of a relation from being a class.
> It also does not allow sets of classes to be defined.  So, defining
> the partition as a relation in OWL-DL is not possible.
I agree with this but then I guess I am misinterpreting something
regarding the OWL DL semantics or the elements that participate in the
binary relationship of the partition.

Going back to the W3C note: http://www.w3.org/TR/swbp-specified-values/.  It
defines two patterns to represent a partition that can be expressed in OWL

I would interpret the partition in Pattern 1 as a binary relationship
between a class :Health_Value and a set of mutually disjoint *individuals*
that cover the class {:poor_health, :medium_health, good_health}.

I would interpret the partition in Pattern 2 (both variant 1 and 2) as a
binary relationship between a class :Health_Value and a set of mutually
disjoint *subclasses* that cover the parent class
{:Good_health_value, :Medium_health_value, :Poor_health_value}.

The definition of partition that you give (which *cannot* be expressed in
OWL-DL) "seems to align" to the definition in Pattern 2 (which *can* be
expressed in OWL DL).  That's why I think I must be misunderstanding

Defining the
> partition as a class means that there are a number of instances of
> the partition, which seems to violate the meaning of partition,
> instantiation, or both.  The partition could be defined as an
> instance, but relating the instance to a rule defining the meaning of
> the partition is problematic.
> > Some notes/clarifications about this model:
> > * For space and simplicity, some important aspects of the Normalisation
> > mechanism have not been fully specified, such as the fact that the
> > subclasses of :Wine associated to a classification criterion are "defined
> > classes" (:MerlotWine, ..., WhiteWine) and the specific wine subclasses
> > to be automatically classified by the reasoner are "primitive classes"
> > (:SpecificXxxWineClass).  For example, [1] and [2] show the definitions
> > of :MerlotWine and :SpecificMerlotWineClass respectively.
> This apparently is intended allow for a future definition of a WhiteMerlotWine.
> > These definitions would cause the reasoner to infer that
> > :SpecificMerlotWineClass is a subclass of :MerlotWine.  (Perhaps this link
> > might help illustrate what I'm trying to refer to:
> > http://www.gong.manchester.ac.uk/odp/html/Normalisation.html).
> This reference does not duplicate classes with differently named subclasses
> with the same apparent meaning.
I'm afraid I'm not sure which classes from the :Wine example fit into that

> > * The "wine by color" classification criteria is represented using the
> > "Specified Values" value partition pattern.
> > And again, looking at the inheritance structure of the :Wine hierarchy now
> > *normalised*, it presents the *same* issue mentioned at the beginning of
> > my original email!
> This is because the partitions were defined as subclasses of the classes
> which they were intended to partition.  The partitions are objects which
> can not be represented in OWL-DL.
> > Which was that we could argue that the inheritance structure is not
> > satisfactory because "different concepts are represented by classes at
> > the same level".  Sorry for repeating myself, but the structure seems to
> > be "asking" for some classes to separate these different concept groups.
> The classes it is asking for are classes of classes ("meta-classes").  But
> since such can not be defined in OWL-DL, you have a problem.
Yes, I can see this now.

> > The already mentioned :WineByColor, :WineByGrape and now maybe even a
> > :SpecificWine or :NamedWine or for consistency :WineByName classes.
> These are classes of classes, not subclasses of Wine; therefore,
> the below structure does not work.

> > The hypothetical inheritance structure would be:
> >    |-- :Wine
> >        |-- :WineByGrape
> >            |-- :MerlotWine
> >            |-- :ChardonnayWine
> >            |-- (etc...)
> > ...
> > And so, this is my dilemma. The ontology is normalised and still
> > seems to "need" this :WineByClassificationCriterion classes.
> You are using a tool that is unable to express such meta-classes.

> > Based on the replies gathered so far, the consensus seems to be
> > that using a class is not the best approach to represent a
> > "classification criterion" in OWL DL.
> Correct.
> > Allow me to recap.  The suggestion instead, is to use a restriction
> > on a property to define the classes that form the "classification
> > criterion".
> Not quite.  Classes defined by a given *pattern* of rule are all
> classes of one meta-type.  Classes defined by a different pattern
> are of a different meta-type.  OWL-DL allows one to define
> multiple rules of the same pattern, but it does not allow the
> definition of the rule *patterns*.
I'm afraid I'm not sure what the generic terms "pattern", "rule",
"meta-type" refer to in this case or how to interpret the statements in the
paragraph in terms of OWL.  It would be very helpful if you could you point
out a specific example to help illustrate what it is being referred to by
"meta-type", "pattern of rule", "multiple rules of the same pattern", "the
definition of the rule patterns"...

> > For example, :MerlotWine is the restriction of the property
> > :madeFromGrape to :MerlotGrape (see [1]),
> Not the restriction itself, but the class defined by the restriction.
> > :RedWine is the restriction of the property :hasColor to :Red,
> Again, :RedWine is the class *defined* by the restriction.
> > and so on.  However, as part of the Normalisation mechanism, all
> > these properties and restrictions are already asserted in the
> > ontology model!
> Sure.
> > This leaves me thinking that the "vision" of  separating the
> > post-normalisation flat hierarchy of subclasses of :Wine (or
> > :Person or in general any other normalised :DomainConcept) into
> > homogeneous subgroups is *not really necessary or possible* after
> > all, given the semantics of OWL DL.
> It is not possible using the semantics of OWL-DL.
> The classes from the different meta-classes are not necessarily
> disjoint, so making a flat hierarchy instead of a directed
> acyclic graph is not possible.
> It is possible to define the meta-classes in more powerful languages,
> howerver.
> -- doug
> > Not sure if everyone would agree with that as the final conclusion
> > but if that was the case, it would feel somehow kind of hard to accept.
> > ...
> > Any comments or feedback are indeed very welcome.
> > Regards,
> > Bene Rodriguez-Castro
> The following two definitions are identical.  I'm guessing that
> you intended to make the second one a rdfs:subClassOf :RedWine ;
> -- doug
 I don't think they are *identical* thou.  These are the intended
definitions.  There is one difference:
The class :MerlotWine is *equivalent* to the class defined by the someValue
restriction on the the property :madeFromGrape.
The class :SpecificMerlotWineClass is a *subclass* of the class defined by
the same restriction of the same property.
This representation allows a reasoner to infer that :SpecificMerlotWineClass
is a subclass of :MerlotWine.
This sort of "pattern" is one of the keys in the Normalization mechanism in
order to enable a reasoner to infer all multiple inheritance relations among
the classes involved in an ontology model.

> > ----
> > [1] Definition of :MerlotWine.
> :MerlotWine rdf:type owl:Class ;
>         rdfs:subClassOf :Wine ;
>         owl:equivalentClass [ rdf:type owl:Restriction ;
>                               owl:onProperty :madeFromGrape ;
>                               owl:someValuesFrom :MerlotGrape ] .
> [2] Defintion of :SpecificMerlotWineClass.
> :SpecificMerlotWineClass rdf:type owl:Class ;
>         rdfs:subClassOf :Wine ,
>                         [ rdf:type owl:Restriction ;
>                           owl:onProperty :madeFromGrape ;
>                           owl:someValuesFrom :MerlotGrape ] .
Received on Thursday, 29 April 2010 19:02:47 UTC

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