[Top] [All Lists]

Re: [ontolog-forum] The notion of a "classification criterion" as a clas

To: "[ontolog-forum]" <ontolog-forum@xxxxxxxxxxxxxxxx>, public-owl-dev <public-owl-dev@xxxxxx>
From: Bene Rodriguez-Castro <beroca@xxxxxxxxx>
Date: Thu, 29 Apr 2010 20:02:10 +0100
Message-id: <i2jea8cd28f1004291202s57fd1991ufff31ac94faa0460@xxxxxxxxxxxxxx>
Hi Doug,
I found very useful reference [3] from your first reply ( Instances of Instances Modeled via Higher-Order Classes ).  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 yet).

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

On Sun, Apr 25, 2010 at 6:08 AM, doug foxvog <doug@xxxxxxxxxx> wrote:
Benedicto Rodriguez <br205r@xxxxxxxxxxxxxxx> 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: http://www.w3.org/TR/swbp-specified-values/.  

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 OWL").

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 DL.

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 something.

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 description. 

> * 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.


> 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!

> 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,

-- 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 ] .

Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/  
Config Subscr: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/  
Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/ 
To join: http://ontolog.cim3.net/cgi-bin/wiki.pl?WikiHomePage#nid1J
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx    (01)

<Prev in Thread] Current Thread [Next in Thread>