To SubClass or not to SubClass that is the question

classic Classic list List threaded Threaded
9 messages Options
Reply | Threaded
Open this post in threaded view
|

To SubClass or not to SubClass that is the question

William Fitzgerald-2
Dear all,

I am relatively new to the world of ontology engineering and I would
like to raise a debate on when to subclass and when to instantiate.

Looking at both the Wine ontology (lots of individuals) and the Pizza
ontology (99% subclasses) seems to raise some issues that are confusing me.

The Manchester University school of thought seems to suggest that its
better to focus on subclassing rather than on individuals for
inferencing reasons.

Within the infamous Pizza Tutorial the class PizzaTopping is constantly
subclassed (CheeseTopping, VegetableTopping etc) and I can relate to
this just fine.

Later the tutorial introduces "INDIVIDUALS" of a class Country, I can
understand this as it doesn't make sense to have a subclass called
England for example.

However, looking at the way the Pizza ontology is constructed is making
me ask certain questions as to how I can construct my own models and do
so in an accurate way.

The focus is in the OWL-DL space so we can reason over the model.

QUESTION 1:
Is it wrong to have a class Country and have subclasses England, Italy
etc? Couldn't the class England have just one individual called
"england"? So in other words the class England has one element called
"england".

Country <---England {england}
         <--- Italy

If this is indeed a very wrong approach the this leads to question 2.

QUESTION 2:

How come its fine to have a class called TomatoTopping? Yes, indeed a
Tomato is a "kind-of" topping and its very different to an onion for
example.

But could it also have been modeled as the class VegetableTopping with
individuals {Tomato, Onion, Tomato1, Tomato2 etc}?

Essentially I am trying to model some network related stuff in
particular wanting to derive correct command line syntax (or a a set of
input arguments than can be written to a file so that a particular
service can open and take inferred result as input) from a model that
represents the network programs command arguments. I think this can be
achieved without having to deal with individuals. I could just take
class names returned to me and parse them out into command syntax. I
think the PIZZAFINDER applet works on this principle.

So essentially my space would be network configurations and network
programs take arguments and do their intended magic. I want to model for
example a particular program or service then infer the arguments, then
parse them and feed into a waiting and listening program or service so
that service can perform its intended goal. A configuration file would
simply be a list of inferred arguments taken from the OWL-DL model.

In this model I cannot decide do I subclass or instantiate!!! Take for
example a class called Port to represent computer port numbers and if I
follow the Manchester University style I would have subclasses called
HTTP, SSH etc. (These subclasses could if required have 1 individual
like the England example above: HTTP {http})

PortFilter <--- HTTP
            <--- SSH

Looking at this I can say that port 80 or HTTP is really a "kind of"
port, isn't it?

I could have on the other hand created a class Port and had individuals
  HTTP, SSH etc.

PortFilter {HTTP, SSH}

This would be like having a class Person and individuals {tom, mary},
both tom and mary are different even though they are still people so
maybe ports should be represented in this way also. Rather than saying
HTTP is-a Port and its disjoint from SSH, I could say http and ssh are
disjoint and are elements of the class Port. Its so confusing of which
route to take!!

Now this is easier said than done. For modeling reasons, I would like to
follow one method of design throughout the model. Suppose I also had a
class called Protocol I can have subclasses called IP,TCP and UDP.

Protocol <--- IP
          <--- TCP
          <--- UCP

Well I wonder can you have a "kind of" TCP? (note: a command argument to
the network program would be "tcp")
Both TCP and UDP should probably be individuals. However, class IP to
represent the set of ip addresses is fine (IP{1.2.3, 4.5.6 etc}).
Although if I take the view of a single element class instead of:

Protocol {tcp, udp}
          <--- IP

I could justify having TCP and UDP as subclassses rather than individuals:
Protocol <--- IP {1.2.3, 4.5.6 etc}
          <--- TCP {tcp}
          <--- UCP {udp}

Because TCP and UDP could be said quite easily to be kinds of Protocol
rather than they are instances of the Protocol class.

I don't seem to see any clear modeling consistency in developing class
Port and Protocol for example. It might just be more ascetically
pleasing to state things as classes rather than instances and vice versa
but what would be best modeling practice standard is another question!

There seems to be no wrong or right way to model :-(

I have built 2 models to represent the same thing, one uses all
subclassing and the other has a lot of individuals (leaf nodes of the
first model). I notice that when I use individuals I loose certain
reasoning constraints.  For example, suppose I have a restriction
hasPort with a cardinality of 1 to the class Port then on the first
model (all subclasses) if I had 2 Existential hasPort restrictions an
inconsistency would show up (great, thats what we want). However I
noticed that the reasoner did not care if i have 2 "hasElement" hasPort
restrictions to class Port individuals!!

In conclusion to the above reasoning issue it is probably best to try
and have as much of the model as possible as subclasses rather than
instances.

comments?

Question 3:
In the Pizza tutorial it suggests it can "search" for pizza's by
creating definition classes. Is this the same a querying the model? Can
i say find me the correct arguments that makes up rule xyx? then like
the pizza example it returns the class names not having to worry about
instances and from here i could then parse out the returned classes
names to correspond to actual syntax arguments required by an awaiting
program listening for commands.

Question 4:
Is query the model at a subsumption level good enough for most things or
should one really focus on creating individuals and using SWRL?

If anyone has any guides, tutorials or other material that focuses on
when one should model something as a subclass or an instance I would be
grateful to be pointed in that direction.


yours sincerely,
Will.

--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

Jan Henke
Dear Will,

probably there are no black / white wrong /right answers about modeling,
however let me give you some hints:

One distinguishing question could be: Do you want to
 - *add* a slot (create a property)
or do you want to
 - *fill* a slot (set a property value)?

In the first case you would subclass. You would e.g. say that bird is a
subclass of animal because I can add the property numberOfFeathers.

In the second case you would instantiate. You would e.g. say that Great
Britain is an instance of country because you can set the value of
countryCode to "GB".

Another question to consider if you want to decide whether to create a class
is: Can *several* instances be created of it? I.e. a class with only one
instance makes no sense to me because a class is a kind of template of which
you want to reuse something but if you instantiate it only once, you don't
really gain so much.

Best regards
Jan


 

> -----Urspr√ľngliche Nachricht-----
> Von: [hidden email]
> [mailto:[hidden email]] Im Auftrag
> von william fitzgerald
> Gesendet: Freitag, 16. Februar 2007 11:41
> An: [hidden email]
> Betreff: [protege-owl] To SubClass or not to SubClass that is
> the question
>
> Dear all,
>
> I am relatively new to the world of ontology engineering and
> I would like to raise a debate on when to subclass and when
> to instantiate.
>
> Looking at both the Wine ontology (lots of individuals) and
> the Pizza ontology (99% subclasses) seems to raise some
> issues that are confusing me.
>
> The Manchester University school of thought seems to suggest
> that its better to focus on subclassing rather than on
> individuals for inferencing reasons.
>
> Within the infamous Pizza Tutorial the class PizzaTopping is
> constantly subclassed (CheeseTopping, VegetableTopping etc)
> and I can relate to this just fine.
>
> Later the tutorial introduces "INDIVIDUALS" of a class
> Country, I can understand this as it doesn't make sense to
> have a subclass called England for example.
>
> However, looking at the way the Pizza ontology is constructed
> is making me ask certain questions as to how I can construct
> my own models and do so in an accurate way.
>
> The focus is in the OWL-DL space so we can reason over the model.
>
> QUESTION 1:
> Is it wrong to have a class Country and have subclasses
> England, Italy etc? Couldn't the class England have just one
> individual called "england"? So in other words the class
> England has one element called "england".
>
> Country <---England {england}
>          <--- Italy
>
> If this is indeed a very wrong approach the this leads to question 2.
>
> QUESTION 2:
>
> How come its fine to have a class called TomatoTopping? Yes,
> indeed a Tomato is a "kind-of" topping and its very different
> to an onion for example.
>
> But could it also have been modeled as the class
> VegetableTopping with individuals {Tomato, Onion, Tomato1,
> Tomato2 etc}?
>
> Essentially I am trying to model some network related stuff
> in particular wanting to derive correct command line syntax
> (or a a set of input arguments than can be written to a file
> so that a particular service can open and take inferred
> result as input) from a model that represents the network
> programs command arguments. I think this can be achieved
> without having to deal with individuals. I could just take
> class names returned to me and parse them out into command
> syntax. I think the PIZZAFINDER applet works on this principle.
>
> So essentially my space would be network configurations and
> network programs take arguments and do their intended magic.
> I want to model for example a particular program or service
> then infer the arguments, then parse them and feed into a
> waiting and listening program or service so that service can
> perform its intended goal. A configuration file would simply
> be a list of inferred arguments taken from the OWL-DL model.
>
> In this model I cannot decide do I subclass or instantiate!!!
> Take for example a class called Port to represent computer
> port numbers and if I follow the Manchester University style
> I would have subclasses called HTTP, SSH etc. (These
> subclasses could if required have 1 individual like the
> England example above: HTTP {http})
>
> PortFilter <--- HTTP
>             <--- SSH
>
> Looking at this I can say that port 80 or HTTP is really a "kind of"
> port, isn't it?
>
> I could have on the other hand created a class Port and had
> individuals
>   HTTP, SSH etc.
>
> PortFilter {HTTP, SSH}
>
> This would be like having a class Person and individuals
> {tom, mary}, both tom and mary are different even though they
> are still people so maybe ports should be represented in this
> way also. Rather than saying HTTP is-a Port and its disjoint
> from SSH, I could say http and ssh are disjoint and are
> elements of the class Port. Its so confusing of which route to take!!
>
> Now this is easier said than done. For modeling reasons, I
> would like to follow one method of design throughout the
> model. Suppose I also had a class called Protocol I can have
> subclasses called IP,TCP and UDP.
>
> Protocol <--- IP
>           <--- TCP
>           <--- UCP
>
> Well I wonder can you have a "kind of" TCP? (note: a command
> argument to the network program would be "tcp") Both TCP and
> UDP should probably be individuals. However, class IP to
> represent the set of ip addresses is fine (IP{1.2.3, 4.5.6 etc}).
> Although if I take the view of a single element class instead of:
>
> Protocol {tcp, udp}
>           <--- IP
>
> I could justify having TCP and UDP as subclassses rather than
> individuals:
> Protocol <--- IP {1.2.3, 4.5.6 etc}
>           <--- TCP {tcp}
>           <--- UCP {udp}
>
> Because TCP and UDP could be said quite easily to be kinds of
> Protocol rather than they are instances of the Protocol class.
>
> I don't seem to see any clear modeling consistency in
> developing class Port and Protocol for example. It might just
> be more ascetically pleasing to state things as classes
> rather than instances and vice versa but what would be best
> modeling practice standard is another question!
>
> There seems to be no wrong or right way to model :-(
>
> I have built 2 models to represent the same thing, one uses
> all subclassing and the other has a lot of individuals (leaf
> nodes of the first model). I notice that when I use
> individuals I loose certain reasoning constraints.  For
> example, suppose I have a restriction hasPort with a
> cardinality of 1 to the class Port then on the first model
> (all subclasses) if I had 2 Existential hasPort restrictions
> an inconsistency would show up (great, thats what we want).
> However I noticed that the reasoner did not care if i have 2
> "hasElement" hasPort restrictions to class Port individuals!!
>
> In conclusion to the above reasoning issue it is probably
> best to try and have as much of the model as possible as
> subclasses rather than instances.
>
> comments?
>
> Question 3:
> In the Pizza tutorial it suggests it can "search" for pizza's
> by creating definition classes. Is this the same a querying
> the model? Can i say find me the correct arguments that makes
> up rule xyx? then like the pizza example it returns the class
> names not having to worry about instances and from here i
> could then parse out the returned classes names to correspond
> to actual syntax arguments required by an awaiting program
> listening for commands.
>
> Question 4:
> Is query the model at a subsumption level good enough for
> most things or should one really focus on creating
> individuals and using SWRL?
>
> If anyone has any guides, tutorials or other material that
> focuses on when one should model something as a subclass or
> an instance I would be grateful to be pointed in that direction.
>
>
> yours sincerely,
> Will.
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group, Waterford
> Institute of Technology, Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing:
> http://protege.stanford.edu/doc/faq.html#01a.03 
>

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

Thomas Russ
In reply to this post by William Fitzgerald-2

On Feb 16, 2007, at 2:41 AM, william fitzgerald wrote:

> Dear all,
>
> I am relatively new to the world of ontology engineering and I would
> like to raise a debate on when to subclass and when to instantiate.

This is one of the hardest modeling questions to answer in any
definitive way, because it really depends on the way you plan
to use the ontology.

Classes and instances form the domain of discourse, and there
are some differences in the way you interact with them.  For
some things classes are easier and for others instances.

> QUESTION 1:
> Is it wrong to have a class Country and have subclasses England, Italy
> etc? Couldn't the class England have just one individual called
> "england"? So in other words the class England has one element called
> "england".
>
> Country <---England {england}
>          <--- Italy
>
> If this is indeed a very wrong approach the this leads to question 2.

My first impression is that this would perhaps be improper, because
England is not really a specialization of country.
"English Speaking Country" would fit more in with a specialization
of "Country".

But further thought leads to the consideration of, say, instances that
might represent England at different times.  If one wanted to group
England-in-the-1970s with England-in-the-1960s, etc. into a class, what
would one want to call that class?  Perhaps that is a good place for
an England class.  I would still think, though, that the England class
would be an instance of the meta-class Country, rather than a subclass
of it.


>
> QUESTION 2:
>
> How come its fine to have a class called TomatoTopping? Yes, indeed a
> Tomato is a "kind-of" topping and its very different to an onion for
> example.
>
> But could it also have been modeled as the class VegetableTopping with
> individuals {Tomato, Onion, Tomato1, Tomato2 etc}?

Well, suppose you wanted to be able to differentiate between the
tomato topping on my pizza and the one on yours.  If there is only
a single TomatoTopping object, then they can't be distinguished.

This is the real nexus of the instance-vs-concept question:  What
is the level of distinction that one needs to be able to draw?  What
is the domain of discourse?

If one were interested in discussing different models of cars, then
it may be sufficient to make things like a Toyota-Camry be an instance,
since the domain of discourse is types of cars.  If you are the Toyota
engineering department, then this will probably do fine.  If you are
the sales department, though you car about individual cars themselves
and would need to have Toyota-Camry be a class so that you can have
a number of different instances of it.


>
> Essentially I am trying to model some network related stuff in
> particular wanting to derive correct command line syntax (or a a  
> set of
> input arguments than can be written to a file so that a particular
> service can open and take inferred result as input) from a model that
> represents the network programs command arguments. I think this can be
> achieved without having to deal with individuals. I could just take
> class names returned to me and parse them out into command syntax. I
> think the PIZZAFINDER applet works on this principle.
>
> So essentially my space would be network configurations and network
> programs take arguments and do their intended magic. I want to  
> model for
> example a particular program or service then infer the arguments, then
> parse them and feed into a waiting and listening program or service so
> that service can perform its intended goal. A configuration file would
> simply be a list of inferred arguments taken from the OWL-DL model.
>
> In this model I cannot decide do I subclass or instantiate!!! Take for
> example a class called Port to represent computer port numbers and  
> if I
> follow the Manchester University style I would have subclasses called
> HTTP, SSH etc. (These subclasses could if required have 1 individual
> like the England example above: HTTP {http})
>
> PortFilter <--- HTTP
>             <--- SSH
>
> Looking at this I can say that port 80 or HTTP is really a "kind of"
> port, isn't it?

I prefer to use more specific terminology.  I tend to favor the
use of set terminology for discussing classes.

Would you say  "port 80" is a subset of "computer port"?
Or is it a distinct individual computer port?

This gives some guidance, but still runs into the difficulty I
discussed above, because if you make "port-80" be an individual,
then you can't talk about port 80 on different physical computer
systems.

The bottom line is that you need to be somewhat guided by what
makes it easiest to express what you need to say, and what makes
it easiest to use for the particular application you have in mind.

Since this is essentially an engineering decision, you will have
to weigh the costs and benefits of the different approaches and
make a decision.

There are certain modeling decisions which are clearly wrong,
in that they don't conform to the semantics of the language,
but the concept/instance one is often not clear-cut in that way.

> I could have on the other hand created a class Port and had  
> individuals
>   HTTP, SSH etc.
>
> PortFilter {HTTP, SSH}
>
> This would be like having a class Person and individuals {tom, mary},
> both tom and mary are different even though they are still people so
> maybe ports should be represented in this way also. Rather than saying
> HTTP is-a Port and its disjoint from SSH, I could say http and ssh are
> disjoint and are elements of the class Port. Its so confusing of which
> route to take!!
>
> Now this is easier said than done. For modeling reasons, I would  
> like to
> follow one method of design throughout the model. Suppose I also had a
> class called Protocol I can have subclasses called IP,TCP and UDP.
>
> Protocol <--- IP
>           <--- TCP
>           <--- UCP
>
> Well I wonder can you have a "kind of" TCP? (note: a command  
> argument to
> the network program would be "tcp")
> Both TCP and UDP should probably be individuals. However, class IP to
> represent the set of ip addresses is fine (IP{1.2.3, 4.5.6 etc}).
> Although if I take the view of a single element class instead of:
>
> Protocol {tcp, udp}
>           <--- IP
>
> I could justify having TCP and UDP as subclassses rather than  
> individuals:
> Protocol <--- IP {1.2.3, 4.5.6 etc}
>           <--- TCP {tcp}
>           <--- UCP {udp}
>
> Because TCP and UDP could be said quite easily to be kinds of Protocol
> rather than they are instances of the Protocol class.
>
> I don't seem to see any clear modeling consistency in developing class
> Port and Protocol for example. It might just be more ascetically
> pleasing to state things as classes rather than instances and vice  
> versa
> but what would be best modeling practice standard is another question!
>
> There seems to be no wrong or right way to model :-(

This is often true.  There are just competing designs.

>
> I have built 2 models to represent the same thing, one uses all
> subclassing and the other has a lot of individuals (leaf nodes of the
> first model). I notice that when I use individuals I loose certain
> reasoning constraints.  For example, suppose I have a restriction
> hasPort with a cardinality of 1 to the class Port then on the first
> model (all subclasses) if I had 2 Existential hasPort restrictions an
> inconsistency would show up (great, thats what we want). However I
> noticed that the reasoner did not care if i have 2 "hasElement"  
> hasPort
> restrictions to class Port individuals!!
>
> In conclusion to the above reasoning issue it is probably best to try
> and have as much of the model as possible as subclasses rather than
> instances.
>
> comments?
>
> Question 3:
> In the Pizza tutorial it suggests it can "search" for pizza's by
> creating definition classes. Is this the same a querying the model?  
> Can
> i say find me the correct arguments that makes up rule xyx? then like
> the pizza example it returns the class names not having to worry about
> instances and from here i could then parse out the returned classes
> names to correspond to actual syntax arguments required by an awaiting
> program listening for commands.

Well, it is a query of a sort.  You construct a definition and then
use classification to tell you where in the hierarchy such a class
appears.  This only works if you have a large number of defined
classes, since otherwise there isn't much that the subsumption inference
can tell you.

It does mean you have to construct a class definition describing an
instance rather than just producing the instance itself.  This requires
a little bit more abstraction.

Also, the answer you get isn't a direct answer to the question, but
rather sets of more general (super), more specific (sub) or equivalent
classes.

>
> Question 4:
> Is query the model at a subsumption level good enough for most  
> things or
> should one really focus on creating individuals and using SWRL?

It depends on what you want to do.

Generally, it is much easier to formulate queries at an instance
level rather than at the description level.  Contrast:

   find instance ?p with topping = onion.

   find subclasses of class ?pc with restriction (has sometopping =  
onion).


>
> If anyone has any guides, tutorials or other material that focuses on
> when one should model something as a subclass or an instance I  
> would be
> grateful to be pointed in that direction.
>
>
> yours sincerely,
> Will.
>
> --
> William M. Fitzgerald,
> PhD Student,
> Telecommunications Software & Systems Group,
> Waterford Institute of Technology,
> Cork Rd.
> Waterford.
> Office Ph: +353 51 302937
> Mobile Ph: +353 87 9527083
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/ 
> faq.html#01a.03

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

William Fitzgerald-2
In reply to this post by Jan Henke
Thanks Jan for your informative response.

For me my end goal is to retrieve a set of parameters (more so than
individuals) for example Linux netfilter firewall parameters.

for example:
iptables -A INPUT -s 192.168.1.1 -p tcp --dport ssh -j ACCEPT

this command syntax allows tcp based ssh traffic into the firewall from
the node with ip address 192.168.1.1.

Parameters here are INPUT, 192.168.1.1, tcp, ssh and ACCEPT.

So my port class currently models a subclass of PortFilter called
SSHFilter. I could then create a single individual of SSHFilter called
"ssh" to have a datatype value of port 22.

However you suggest that a one individual class is not good practice.

So maybe a port is an individual of PortFilter rather than a subclass!

The same applied when I want the model to infer the correct protocol to
go with the -p option in this case its the string 'tcp'. Again in the
current model this is a subclass of the class ProtocolFilter. Again the
class TCPFilter would have 1 individual called "tcp".

Given the ProtocolFilter Class it is based on Subclassing with one
individual for TCP and UDP:
ProtocolFilter <--- IP {1.2.3, 4.5.6 etc}
                <--- TCP {tcp}
                <--- UCP {udp}

If I take the individual approach then it would be as follows: 2
individuals and 1 subclass to represent ip addresses.
ProtocolFilter {tcp, udp}
              <--- IP {1.2.3, 4.5.6 etc}

However wouldn't that mean that something that is an IP address
(individual from IP subclass) is also a tcp or udp individual (from
super class ProtocolFilter)? this is not what we want.


Bottom line is I want to ask the DL based model for what kind of rule
components (i suppose by classification) is required for a particular
job. Retrieve a result and parse it out into the correct command line
syntax the iptables rule above. It might be possible to avoid
individuals like the PIZZAFINDER application does and just query for
class names and then parse these names into the correct syntax like
class SSHFilter 'ssh' or 22, class TCPFilter becomes 'tcp' etc.

I wonder would I also benefit from using iS instance store. I am not at
all familiar with its workings as of yet but based on what I have
already stated if anyone thinks it could benefit then let me know.

I will need to think more about this and learn better modeling
techniques as I go along. I know if introduce a lot of individuals I
loose some of the reasoning capabilities of the model but at the same
time I don't want to reason for the sake of reasoning but I do want a
true representation of a real world problem.

Just a note about england in a different context, England could be a
subclass of the class "UK" rather than an immediate individual of
Country. The UK or united kingdom is made up of several countries such
as England, Wales and Scotland. So the UK could be a subclass of
Country. I presume the UK class would have subclasses ENGLAND, WALES and
SCOTALND, as having an individual 'england' would not be an instance of
the UK but rather a part of it. I guess it all boils down to what is
being modeled ;-)

kind regards,
Will.



Jan Henke wrote:

> Dear Will,
>
> probably there are no black / white wrong /right answers about modeling,
> however let me give you some hints:
>
> One distinguishing question could be: Do you want to
>  - *add* a slot (create a property)
> or do you want to
>  - *fill* a slot (set a property value)?
>
> In the first case you would subclass. You would e.g. say that bird is a
> subclass of animal because I can add the property numberOfFeathers.
>
> In the second case you would instantiate. You would e.g. say that Great
> Britain is an instance of country because you can set the value of
> countryCode to "GB".
>
> Another question to consider if you want to decide whether to create a class
> is: Can *several* instances be created of it? I.e. a class with only one
> instance makes no sense to me because a class is a kind of template of which
> you want to reuse something but if you instantiate it only once, you don't
> really gain so much.
>
> Best regards
> Jan
>
>
>  
>
>> -----Urspr√ľngliche Nachricht-----
>> Von: [hidden email]
>> [mailto:[hidden email]] Im Auftrag
>> von william fitzgerald
>> Gesendet: Freitag, 16. Februar 2007 11:41
>> An: [hidden email]
>> Betreff: [protege-owl] To SubClass or not to SubClass that is
>> the question
>>
>> Dear all,
>>
>> I am relatively new to the world of ontology engineering and
>> I would like to raise a debate on when to subclass and when
>> to instantiate.
>>
>> Looking at both the Wine ontology (lots of individuals) and
>> the Pizza ontology (99% subclasses) seems to raise some
>> issues that are confusing me.
>>
>> The Manchester University school of thought seems to suggest
>> that its better to focus on subclassing rather than on
>> individuals for inferencing reasons.
>>
>> Within the infamous Pizza Tutorial the class PizzaTopping is
>> constantly subclassed (CheeseTopping, VegetableTopping etc)
>> and I can relate to this just fine.
>>
>> Later the tutorial introduces "INDIVIDUALS" of a class
>> Country, I can understand this as it doesn't make sense to
>> have a subclass called England for example.
>>
>> However, looking at the way the Pizza ontology is constructed
>> is making me ask certain questions as to how I can construct
>> my own models and do so in an accurate way.
>>
>> The focus is in the OWL-DL space so we can reason over the model.
>>
>> QUESTION 1:
>> Is it wrong to have a class Country and have subclasses
>> England, Italy etc? Couldn't the class England have just one
>> individual called "england"? So in other words the class
>> England has one element called "england".
>>
>> Country <---England {england}
>>          <--- Italy
>>
>> If this is indeed a very wrong approach the this leads to question 2.
>>
>> QUESTION 2:
>>
>> How come its fine to have a class called TomatoTopping? Yes,
>> indeed a Tomato is a "kind-of" topping and its very different
>> to an onion for example.
>>
>> But could it also have been modeled as the class
>> VegetableTopping with individuals {Tomato, Onion, Tomato1,
>> Tomato2 etc}?
>>
>> Essentially I am trying to model some network related stuff
>> in particular wanting to derive correct command line syntax
>> (or a a set of input arguments than can be written to a file
>> so that a particular service can open and take inferred
>> result as input) from a model that represents the network
>> programs command arguments. I think this can be achieved
>> without having to deal with individuals. I could just take
>> class names returned to me and parse them out into command
>> syntax. I think the PIZZAFINDER applet works on this principle.
>>
>> So essentially my space would be network configurations and
>> network programs take arguments and do their intended magic.
>> I want to model for example a particular program or service
>> then infer the arguments, then parse them and feed into a
>> waiting and listening program or service so that service can
>> perform its intended goal. A configuration file would simply
>> be a list of inferred arguments taken from the OWL-DL model.
>>
>> In this model I cannot decide do I subclass or instantiate!!!
>> Take for example a class called Port to represent computer
>> port numbers and if I follow the Manchester University style
>> I would have subclasses called HTTP, SSH etc. (These
>> subclasses could if required have 1 individual like the
>> England example above: HTTP {http})
>>
>> PortFilter <--- HTTP
>>             <--- SSH
>>
>> Looking at this I can say that port 80 or HTTP is really a "kind of"
>> port, isn't it?
>>
>> I could have on the other hand created a class Port and had
>> individuals
>>   HTTP, SSH etc.
>>
>> PortFilter {HTTP, SSH}
>>
>> This would be like having a class Person and individuals
>> {tom, mary}, both tom and mary are different even though they
>> are still people so maybe ports should be represented in this
>> way also. Rather than saying HTTP is-a Port and its disjoint
>> from SSH, I could say http and ssh are disjoint and are
>> elements of the class Port. Its so confusing of which route to take!!
>>
>> Now this is easier said than done. For modeling reasons, I
>> would like to follow one method of design throughout the
>> model. Suppose I also had a class called Protocol I can have
>> subclasses called IP,TCP and UDP.
>>
>> Protocol <--- IP
>>           <--- TCP
>>           <--- UCP
>>
>> Well I wonder can you have a "kind of" TCP? (note: a command
>> argument to the network program would be "tcp") Both TCP and
>> UDP should probably be individuals. However, class IP to
>> represent the set of ip addresses is fine (IP{1.2.3, 4.5.6 etc}).
>> Although if I take the view of a single element class instead of:
>>
>> Protocol {tcp, udp}
>>           <--- IP
>>
>> I could justify having TCP and UDP as subclassses rather than
>> individuals:
>> Protocol <--- IP {1.2.3, 4.5.6 etc}
>>           <--- TCP {tcp}
>>           <--- UCP {udp}
>>
>> Because TCP and UDP could be said quite easily to be kinds of
>> Protocol rather than they are instances of the Protocol class.
>>
>> I don't seem to see any clear modeling consistency in
>> developing class Port and Protocol for example. It might just
>> be more ascetically pleasing to state things as classes
>> rather than instances and vice versa but what would be best
>> modeling practice standard is another question!
>>
>> There seems to be no wrong or right way to model :-(
>>
>> I have built 2 models to represent the same thing, one uses
>> all subclassing and the other has a lot of individuals (leaf
>> nodes of the first model). I notice that when I use
>> individuals I loose certain reasoning constraints.  For
>> example, suppose I have a restriction hasPort with a
>> cardinality of 1 to the class Port then on the first model
>> (all subclasses) if I had 2 Existential hasPort restrictions
>> an inconsistency would show up (great, thats what we want).
>> However I noticed that the reasoner did not care if i have 2
>> "hasElement" hasPort restrictions to class Port individuals!!
>>
>> In conclusion to the above reasoning issue it is probably
>> best to try and have as much of the model as possible as
>> subclasses rather than instances.
>>
>> comments?
>>
>> Question 3:
>> In the Pizza tutorial it suggests it can "search" for pizza's
>> by creating definition classes. Is this the same a querying
>> the model? Can i say find me the correct arguments that makes
>> up rule xyx? then like the pizza example it returns the class
>> names not having to worry about instances and from here i
>> could then parse out the returned classes names to correspond
>> to actual syntax arguments required by an awaiting program
>> listening for commands.
>>
>> Question 4:
>> Is query the model at a subsumption level good enough for
>> most things or should one really focus on creating
>> individuals and using SWRL?
>>
>> If anyone has any guides, tutorials or other material that
>> focuses on when one should model something as a subclass or
>> an instance I would be grateful to be pointed in that direction.
>>
>>
>> yours sincerely,
>> Will.
>>
>> --
>> William M. Fitzgerald,
>> PhD Student,
>> Telecommunications Software & Systems Group, Waterford
>> Institute of Technology, Cork Rd.
>> Waterford.
>> Office Ph: +353 51 302937
>> Mobile Ph: +353 87 9527083
>>
>> _______________________________________________
>> protege-owl mailing list
>> [hidden email]
>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>
>> Instructions for unsubscribing:
>> http://protege.stanford.edu/doc/faq.html#01a.03 
>>
>


--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

William Fitzgerald-2
In reply to this post by Thomas Russ
Thanks Thomas.

I like your info based around the class or individual England and your
automobile examples.

could you explain this further:
"This gives some guidance, but still runs into the difficulty I
discussed above, because if you make "port-80" be an individual,
then you can't talk about port 80 on different physical computer
systems. "

Is it that "port-80" is used by one computer or in my case used by one
iptables/netfilter rules it cannot be used by another?

I would need to have another instance like 'port-80number2' and
'port-80number3' etc etc that are instances of the class PortFilter.

But then if that was the case, how can we relate various pizzas to one
instance of country of origin 'italy'?

I emailed in response to Jan Henke (see thread for this post) some more
information about what I want to retrieve from the DL model of say linux
netfilter. I would like to query it for various rules like the pizza
tutorial can do for pizzas.(maybe i should be looking at other example
ontologies for structure if so please indicate). The model is very
similar in structure to the pizza example with a NamedFirewallRule class
like the NamedPizza class where asserted rule components are glued
together using property restrictions. Then there are defined complete
classes like in the Pizza example to infer new subsumption from the old
asserted model.

Maybe I can follow this route of all subclasses rather than looking at
any individuals and then parse out returned class names and convert to
netfilter command syntax.

I guess in time and with the open communities advice I can make better
judgements in future as I learn more.

If you see any other tools etc that could help I'd appreciate it if
you'd let me now. Possibly SWRL, jess, jena, iS instance store etc.

regards,
Will.



Thomas Russ wrote:

>
> On Feb 16, 2007, at 2:41 AM, william fitzgerald wrote:
>
>> Dear all,
>>
>> I am relatively new to the world of ontology engineering and I would
>> like to raise a debate on when to subclass and when to instantiate.
>
> This is one of the hardest modeling questions to answer in any
> definitive way, because it really depends on the way you plan
> to use the ontology.
>
> Classes and instances form the domain of discourse, and there
> are some differences in the way you interact with them.  For
> some things classes are easier and for others instances.
>
>> QUESTION 1:
>> Is it wrong to have a class Country and have subclasses England, Italy
>> etc? Couldn't the class England have just one individual called
>> "england"? So in other words the class England has one element called
>> "england".
>>
>> Country <---England {england}
>>          <--- Italy
>>
>> If this is indeed a very wrong approach the this leads to question 2.
>
> My first impression is that this would perhaps be improper, because
> England is not really a specialization of country.
> "English Speaking Country" would fit more in with a specialization
> of "Country".
>
> But further thought leads to the consideration of, say, instances that
> might represent England at different times.  If one wanted to group
> England-in-the-1970s with England-in-the-1960s, etc. into a class, what
> would one want to call that class?  Perhaps that is a good place for
> an England class.  I would still think, though, that the England class
> would be an instance of the meta-class Country, rather than a subclass
> of it.
>
>
>>
>> QUESTION 2:
>>
>> How come its fine to have a class called TomatoTopping? Yes, indeed a
>> Tomato is a "kind-of" topping and its very different to an onion for
>> example.
>>
>> But could it also have been modeled as the class VegetableTopping with
>> individuals {Tomato, Onion, Tomato1, Tomato2 etc}?
>
> Well, suppose you wanted to be able to differentiate between the
> tomato topping on my pizza and the one on yours.  If there is only
> a single TomatoTopping object, then they can't be distinguished.
>
> This is the real nexus of the instance-vs-concept question:  What
> is the level of distinction that one needs to be able to draw?  What
> is the domain of discourse?
>
> If one were interested in discussing different models of cars, then
> it may be sufficient to make things like a Toyota-Camry be an instance,
> since the domain of discourse is types of cars.  If you are the Toyota
> engineering department, then this will probably do fine.  If you are
> the sales department, though you car about individual cars themselves
> and would need to have Toyota-Camry be a class so that you can have
> a number of different instances of it.
>
>
>>
>> Essentially I am trying to model some network related stuff in
>> particular wanting to derive correct command line syntax (or a a set of
>> input arguments than can be written to a file so that a particular
>> service can open and take inferred result as input) from a model that
>> represents the network programs command arguments. I think this can be
>> achieved without having to deal with individuals. I could just take
>> class names returned to me and parse them out into command syntax. I
>> think the PIZZAFINDER applet works on this principle.
>>
>> So essentially my space would be network configurations and network
>> programs take arguments and do their intended magic. I want to model for
>> example a particular program or service then infer the arguments, then
>> parse them and feed into a waiting and listening program or service so
>> that service can perform its intended goal. A configuration file would
>> simply be a list of inferred arguments taken from the OWL-DL model.
>>
>> In this model I cannot decide do I subclass or instantiate!!! Take for
>> example a class called Port to represent computer port numbers and if I
>> follow the Manchester University style I would have subclasses called
>> HTTP, SSH etc. (These subclasses could if required have 1 individual
>> like the England example above: HTTP {http})
>>
>> PortFilter <--- HTTP
>>             <--- SSH
>>
>> Looking at this I can say that port 80 or HTTP is really a "kind of"
>> port, isn't it?
>
> I prefer to use more specific terminology.  I tend to favor the
> use of set terminology for discussing classes.
>
> Would you say  "port 80" is a subset of "computer port"?
> Or is it a distinct individual computer port?
>
> This gives some guidance, but still runs into the difficulty I
> discussed above, because if you make "port-80" be an individual,
> then you can't talk about port 80 on different physical computer
> systems.
>
> The bottom line is that you need to be somewhat guided by what
> makes it easiest to express what you need to say, and what makes
> it easiest to use for the particular application you have in mind.
>
> Since this is essentially an engineering decision, you will have
> to weigh the costs and benefits of the different approaches and
> make a decision.
>
> There are certain modeling decisions which are clearly wrong,
> in that they don't conform to the semantics of the language,
> but the concept/instance one is often not clear-cut in that way.
>
>> I could have on the other hand created a class Port and had individuals
>>   HTTP, SSH etc.
>>
>> PortFilter {HTTP, SSH}
>>
>> This would be like having a class Person and individuals {tom, mary},
>> both tom and mary are different even though they are still people so
>> maybe ports should be represented in this way also. Rather than saying
>> HTTP is-a Port and its disjoint from SSH, I could say http and ssh are
>> disjoint and are elements of the class Port. Its so confusing of which
>> route to take!!
>>
>> Now this is easier said than done. For modeling reasons, I would like to
>> follow one method of design throughout the model. Suppose I also had a
>> class called Protocol I can have subclasses called IP,TCP and UDP.
>>
>> Protocol <--- IP
>>           <--- TCP
>>           <--- UCP
>>
>> Well I wonder can you have a "kind of" TCP? (note: a command argument to
>> the network program would be "tcp")
>> Both TCP and UDP should probably be individuals. However, class IP to
>> represent the set of ip addresses is fine (IP{1.2.3, 4.5.6 etc}).
>> Although if I take the view of a single element class instead of:
>>
>> Protocol {tcp, udp}
>>           <--- IP
>>
>> I could justify having TCP and UDP as subclassses rather than
>> individuals:
>> Protocol <--- IP {1.2.3, 4.5.6 etc}
>>           <--- TCP {tcp}
>>           <--- UCP {udp}
>>
>> Because TCP and UDP could be said quite easily to be kinds of Protocol
>> rather than they are instances of the Protocol class.
>>
>> I don't seem to see any clear modeling consistency in developing class
>> Port and Protocol for example. It might just be more ascetically
>> pleasing to state things as classes rather than instances and vice versa
>> but what would be best modeling practice standard is another question!
>>
>> There seems to be no wrong or right way to model :-(
>
> This is often true.  There are just competing designs.
>
>>
>> I have built 2 models to represent the same thing, one uses all
>> subclassing and the other has a lot of individuals (leaf nodes of the
>> first model). I notice that when I use individuals I loose certain
>> reasoning constraints.  For example, suppose I have a restriction
>> hasPort with a cardinality of 1 to the class Port then on the first
>> model (all subclasses) if I had 2 Existential hasPort restrictions an
>> inconsistency would show up (great, thats what we want). However I
>> noticed that the reasoner did not care if i have 2 "hasElement" hasPort
>> restrictions to class Port individuals!!
>>
>> In conclusion to the above reasoning issue it is probably best to try
>> and have as much of the model as possible as subclasses rather than
>> instances.
>>
>> comments?
>>
>> Question 3:
>> In the Pizza tutorial it suggests it can "search" for pizza's by
>> creating definition classes. Is this the same a querying the model? Can
>> i say find me the correct arguments that makes up rule xyx? then like
>> the pizza example it returns the class names not having to worry about
>> instances and from here i could then parse out the returned classes
>> names to correspond to actual syntax arguments required by an awaiting
>> program listening for commands.
>
> Well, it is a query of a sort.  You construct a definition and then
> use classification to tell you where in the hierarchy such a class
> appears.  This only works if you have a large number of defined
> classes, since otherwise there isn't much that the subsumption inference
> can tell you.
>
> It does mean you have to construct a class definition describing an
> instance rather than just producing the instance itself.  This requires
> a little bit more abstraction.
>
> Also, the answer you get isn't a direct answer to the question, but
> rather sets of more general (super), more specific (sub) or equivalent
> classes.
>
>>
>> Question 4:
>> Is query the model at a subsumption level good enough for most things or
>> should one really focus on creating individuals and using SWRL?
>
> It depends on what you want to do.
>
> Generally, it is much easier to formulate queries at an instance
> level rather than at the description level.  Contrast:
>
>   find instance ?p with topping = onion.
>
>   find subclasses of class ?pc with restriction (has sometopping = onion).
>
>
>>
>> If anyone has any guides, tutorials or other material that focuses on
>> when one should model something as a subclass or an instance I would be
>> grateful to be pointed in that direction.
>>
>>
>> yours sincerely,
>> Will.
>>
>> --William M. Fitzgerald,
>> PhD Student,
>> Telecommunications Software & Systems Group,
>> Waterford Institute of Technology,
>> Cork Rd.
>> Waterford.
>> Office Ph: +353 51 302937
>> Mobile Ph: +353 87 9527083
>>
>> _______________________________________________
>> protege-owl mailing list
>> [hidden email]
>> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>>
>> Instructions for unsubscribing:
>> http://protege.stanford.edu/doc/faq.html#01a.03
>


--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

Thomas Russ
In reply to this post by William Fitzgerald-2

On Feb 19, 2007, at 5:20 AM, william fitzgerald wrote:

> Just a note about england in a different context, England could be a
> subclass of the class "UK" rather than an immediate individual of
> Country. The UK or united kingdom is made up of several countries such
> as England, Wales and Scotland. So the UK could be a subclass of
> Country. I presume the UK class would have subclasses ENGLAND,  
> WALES and
> SCOTALND, as having an individual 'england' would not be an  
> instance of
> the UK but rather a part of it. I guess it all boils down to what is
> being modeled ;-)

I would disagree with this analysis.

England is not a more specialized type of United Kindom.
I don't think it is the case that there are instances of England
which must, by definition, be instances of United Kingdom.

The UK is more properly, as your natural language text indicates,
"made of of several countries".  So the proper relationship between
UK and England is not one of class-subclass, anymore than the proper
relation between the organization "United Nations" and "United Kingdom"
is one of class-subclass.  Rather it is one of membership in a
group.

There is often confusion in meaning between the subclassing and
generalized part-of relations (which in includes membership in a
group).  But group membership has a different meaning than the
subclass relation, and needs to be modeled as a distinct relationship.

Repeating from above:

> I presume the UK class would have subclasses ENGLAND, WALES and
> SCOTALND, as having an individual 'england' would not be an  
> instance of
> the UK but rather a part of it.

This shows that you really want the part-of relationship.  If ENGLAND
were a subclass of UK, then having an individual 'england' (presumably
an instance of the ENGLAND class) would also necessarily have to be
an instance of the UK class.  But you really want part-of and not
instance-of or subclass-of.


_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

William Fitzgerald-2
Hi Thomas,

Yes indeed I see exactly what you are saying here. I must be careful in
future as to what is a subclass and what is a part-of propery and not
just what is a subclass and an individual.

thanks for clearing this up.
regards,
Will.


Thomas Russ wrote:

> On Feb 19, 2007, at 5:20 AM, william fitzgerald wrote:
>
>> Just a note about england in a different context, England could be a
>> subclass of the class "UK" rather than an immediate individual of
>> Country. The UK or united kingdom is made up of several countries such
>> as England, Wales and Scotland. So the UK could be a subclass of
>> Country. I presume the UK class would have subclasses ENGLAND,  
>> WALES and
>> SCOTALND, as having an individual 'england' would not be an  
>> instance of
>> the UK but rather a part of it. I guess it all boils down to what is
>> being modeled ;-)
>
> I would disagree with this analysis.
>
> England is not a more specialized type of United Kindom.
> I don't think it is the case that there are instances of England
> which must, by definition, be instances of United Kingdom.
>
> The UK is more properly, as your natural language text indicates,
> "made of of several countries".  So the proper relationship between
> UK and England is not one of class-subclass, anymore than the proper
> relation between the organization "United Nations" and "United Kingdom"
> is one of class-subclass.  Rather it is one of membership in a
> group.
>
> There is often confusion in meaning between the subclassing and
> generalized part-of relations (which in includes membership in a
> group).  But group membership has a different meaning than the
> subclass relation, and needs to be modeled as a distinct relationship.
>
> Repeating from above:
>
>> I presume the UK class would have subclasses ENGLAND, WALES and
>> SCOTALND, as having an individual 'england' would not be an  
>> instance of
>> the UK but rather a part of it.
>
> This shows that you really want the part-of relationship.  If ENGLAND
> were a subclass of UK, then having an individual 'england' (presumably
> an instance of the ENGLAND class) would also necessarily have to be
> an instance of the UK class.  But you really want part-of and not
> instance-of or subclass-of.
>
>
> _______________________________________________
> protege-owl mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
>
> Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
>


--
William M. Fitzgerald,
PhD Student,
Telecommunications Software & Systems Group,
Waterford Institute of Technology,
Cork Rd.
Waterford.
Office Ph: +353 51 302937
Mobile Ph: +353 87 9527083

_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

Thomas Russ

On Feb 20, 2007, at 1:00 AM, william fitzgerald wrote:

> Hi Thomas,
>
> Yes indeed I see exactly what you are saying here. I must be  
> careful in
> future as to what is a subclass and what is a part-of propery and not
> just what is a subclass and an individual.
>
> thanks for clearing this up.

Glad to be able to help.

BTW, a good paper to read about the distinction between part-of
and subclass-of (and a few other relations is):

M. Winston R. Chaffin and D.J. Herrmann,
"A Taxonomy of Part-Whole Relationships,"
Cognitive Science, Vol. 11, 1987, pp. 417-444.

I'm not sure about general electronic availability, but I
can get this from here, but that may be based on my USC affiliation:
<http://www.leaonline.com/doi/abs/10.1207/s15516709cog1104_2>



_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 
Reply | Threaded
Open this post in threaded view
|

Re: To SubClass or not to SubClass that is the question

Thomas Russ
>
> M. Winston R. Chaffin and D.J. Herrmann,
> "A Taxonomy of Part-Whole Relationships,"
> Cognitive Science, Vol. 11, 1987, pp. 417-444.
>
> I'm not sure about general electronic availability, but I
> can get this from here, but that may be based on my USC affiliation:
> <http://www.leaonline.com/doi/abs/10.1207/s15516709cog1104_2>

Here's the Cog Sci source location:

<http://www.cogsci.rpi.edu/CSJarchive/1987v11/i04/p0417p0444/MAIN.PDF>


_______________________________________________
protege-owl mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-owl

Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03