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

On Thu, April 29, 2010 15:02, Bene Rodriguez-Castro said:
> 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.

Thank you.

>  (Reference [4] in the same email does not seem to be publicly available
> yet).

Hopefully, it will be available soon.  I included the reference because
this discussion is archived.

> Some comments in-line below and some requests for clarification if
> possible.
> Thanks,
> Bene
>
> On Sun, Apr 25, 2010 at 6:08 AM, doug foxvog <doug@foxvog.org> wrote:>
>>    Benedicto Rodriguez <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:
> http://www.w3.org/TR/swbp-specified-values/.

This is fine so long as :Value_Partition is removed as being a super-class
-- which you do below.

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

I agree.

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

??? The partition is implemented in the "Representing Specified Values in
OWL" paper, but not as something represented by an OWL term.  The partition
is not a class, but is encoded as a pattern of owl statements.

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

It defines patterns which can *implement* a partition in OWL-DL.  But
it does not define an OWL term which logically means that partition.

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

So would i.  But Pattern 1 does not define a term, with that relationship
as its meaning.  OWL-DL does not allow the definition of a relation whose
first argument is a class.

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

So would i.  But the same problem arises.

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

Pattern 2 can be *used* in OWL-DL.  But it can not be defined as an OWL-
DL term.

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

Agreed.

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

It seemed to me that :SpecificMerlotWineClass and :MerlotWine had the same
meaning.

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

The pattern i am discussing is implemented in the Specified Values paper
by an owl:equivalenceClass to an owl:unionOf a set of classes and a series
of owl:disjointWith statements.  No single statement states that the
superclass is partitioned into the set of disjoint subclasses.

I was considering these statements to be rules even though they appear as
relationships among classes.

>> ...
>> > 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,
>> however.
>>
>> -- 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 raises the issue of what instances of :MerlotWine are not instances
of :SpecificMerlotWineClass.  Does :MerlotWine designate any wine in whose
production at least one Merlot grape is used?  If so, the name is
confusing.

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

The first of these states that anything made from :MerlotGrape is a
:MerlotWine, which is a subClassOf :Wine.  Evidently, the predicate,
:madeFromGrape, does not accept :Jelly or :GrapeJuice in its domain.

The second definition allows :madeFromGrape to have a broader domain,
with :SpecificMerlotWineClass a subClassOf Wine as well as of the
restriction.  The definition gives properties of the class, but does
not precisely define it.

-- doug
=============================================================
doug foxvog    doug@foxvog.org
=============================================================

Received on Saturday, 1 May 2010 04:01:32 UTC