Re: Treating a class as both an individual and a class?

At 9:07 -0500 3/10/03, Peter F. Patel-Schneider wrote:
>From: "Roger L. Costello" <costello@mitre.org>
>Subject: Re: Treating a class as both an individual and a class?
>Date: Mon, 10 Mar 2003 08:08:06 -0500
>
>>
>>  Peter, I sure appreciate all of your excellent comments.  Thanks!
>>
>>  > > Is this good modelling?  Does it effectively model the major
>>  > > features of my hometown? 
>>  >
>>  > No, this is not good modelling. 
>>
>>  Okay then I need help then with creating an example that shows a class
>>  being used as both an individual and as a class.  Could you give me an
>>  example of the class River being used as an individual? (I already have
>>  many examples of using River as a class.)  /Roger
>
>I'm probably not a good person to ask, as I don't generally do that.
>
>However, a possible example would be modelling airline flights, where the
>concept of an airline flight would be a metaclass, a flight number would be
>a class (and an instance of the metaclass), and a particular flight (on a
>particular day) would be a non-class instance.  You could then have
>properties of flight numbers (scheduled departure, destination, etc.) and
>properties of actual flights (actual departure, etc.).
>
>peter

A much simpler example -- many ontologies wish to have some specific, 
non-inherited properties that can be associated with a class, rather 
than an instance.  For example, many biological ontologies want to 
tie terms to things in the Swiss Protein DB or other such 
identifier-based systems, and these terms can't just be normal 
properties associated with the class because they are not to be 
inherited by subclasses.  A standard DL trick is to have a 
"priviledged instance" that contains such properties, and then some 
sort of "extralogical" (generally implementation specific) feature 
for managing these.  For example, we could do something like

:referenceClass a owl:class;

:instanceDataClass a owl:class.

:instanceDataOf a owl:dataTypeProperty;
    rdfs:range a :instanceDataClass.     (note: would be better to use local
                                           restrictions -but I do this for
                                          clarity)
:uniqueIdentifier a owl:dataTypeProperty;
    rdfs:range xsd:string.

adenocarcinoma a owl:referenceClass.

adenocarcinomaInstanceData a :instanceDataClass;
    instanceDataOf :adenocarcinoma;
    :uniqueIdentifier  "XVY27398".

One could now say things like this string is a 
owl:functionalProperty, or include other such stuff.  The key point 
is that if we create a subClassOf adenocarcinoma, we now have a way 
that it won't get the uniqueIdentifier, and also the 
uniqueIdentifiers won't be inherited by the subclass.

Another way to do this is to use a property directly on the class, 
and the current semantics for OWL Full would say that the subclasses 
of the class wouldn't inherit instance properties - so I could simply 
say

:adenocarcinoma a owl:class;
   :uniqueIdentified "XVY27398".

to get the same effect.

  -JH




-- 
Professor James Hendler				  hendler@cs.umd.edu
Director, Semantic Web and Agent Technologies	  301-405-2696
Maryland Information and Network Dynamics Lab.	  301-405-6707 (Fax)
Univ of Maryland, College Park, MD 20742	  240-731-3822 (Cell)
http://www.cs.umd.edu/users/hendler

Received on Tuesday, 11 March 2003 02:15:36 UTC