- From: Hans Teijgeler <hans.teijgeler@quicknet.nl>
- Date: Sun, 16 Oct 2005 13:19:41 +0200
- To: "'Hans Teijgeler'" <hans.teijgeler@quicknet.nl>, <semantic-web@w3c.org>
- Cc: "Paap, Onno" <onno.paap@ezzysurf.com>, "'West, Matthew R SIPC-OFD/321'" <matthew.west@shell.com>, "'Sullivan, Jan'" <jan.sullivan@informationlogic.co.uk>
- Message-Id: <200510161119.j9GBJiWc011479@vmx70.multikabel.net>
Hi Dick, Valentin, Jos, Geoff and Benjamin,
I have collected the essence of this thread, just to find where the
unanswered questions keep lingering. These unanswered questions are listed
below. Please address these and try to bring these to a solution.
Unanswered questions:
1.Dick <> : Then OWL allows using a subClass (Mustangs) of Car or an
instance (myMustang) of Car as an object ???
2.Hans <> : For the latter I don't know what the object of that rdf:type is,
the owl:Class or the RDF extension of it.
3.Hans <> : So, we create an owl:Thing "Mustangs" that is typed with the
owl:Class "Mustangs", and is the "extension" of that Class. Right?
4.Benjamin <> : So, whenever a reasoner encounters a #Mustangs individual,
shouldn't it be able to deduce the manufacturer to be #FordCompany?
The final solution seems to gravitate to that suggested by Geoff and
Benjamin, although I must say that I do't really like it because to me it
looks like a work-around.
>From the beginning I have struggled with chapter 3.1.3 of the OWL Guide. So
let me ask this question: If I have:
<owl:Thing rdf:ID="Mustang"/>
<owl:Thing rdf:about="#Mustang">
<rdf:type rdf:resource="http://www.example.org/library#Mustang"/>
</owl:Thing>
then does this mean that I have here the class extension? (see OWL Web
Ontology Language Reference chapter 3: "Classes provide an abstraction
mechanism for grouping resources with similar characteristics. Like RDF
classes, every OWL class is associated with a set of individuals, called the
class extension."
If so, and if myMustang is typed with this c lass extension, then I'd think
that the OWL logic could assess that Ford also is the manufacturer of
myMustang:
=====================
RESUMING:
Please shoot at what I have concluded from the thread below. Please tell me
where my code is incorrect, redundant, unwieldy, or whatever. I need some
quality benchmark before I use such code a thousand times and then find out
that it does not do the job:
In an assumed ontology http://www.example.org/library:
--------------------------------------------------------------------
...
<owl:Property rdf:ID="isManufacturerOf">
<rdf:domain rdf:resource="#Manufacturer"/>
<rdf:range rdf:resource="#Artifact"/>
</owl:Property>
<owl:Property rdf:ID="hasAsManufacturer">
<owl:inverseOf rdf:resource="#isManufacturerOf"/>
</owl:Property>
...
<owl:Class rdf:ID="Organization"/>
<owl:Class rdf:ID="Company">
<rdfs:subClassOf rdf:resource="#Organization"/>
</owl:Class>
<owl:Class rdf:ID="Manufacturer">
<rdfs:subClassOf rdf:resource="#Company"/>
</owl:Class>
<owl:Class rdf:ID="CarManufacturer">
<rdfs:subClassOf rdf:resource="#Manufacturer"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#isManufacturerOf"/>
<owl:hasValue rdf:resource="#Car"/>
</owl:Restriction>
</owl:Class>
...
<owl:Class rdf:ID="Artifact"/>
<owl:Class rdf:ID="Vehicle">
<rdfs:subClassOf rdf:resource="#Artifact"/>
</owl:Class>
<owl:Class rdf:ID="Car">
<rdfs:subClassOf rdf:resource="#Vehicle"/>
</owl:Class>
<owl:Class rdf:ID="Mustang">
<rdfs:subClassOf rdf:resource="#Car"/>
</owl:Class>
<owl:Class rdf:ID="Scorpio">
<rdfs:subClassOf rdf:resource="#Car"/>
</owl:Class>
...
In an assumed ontology http://www.example.org/projectA :
----------------------------------------------------------------------
...
<owl:Thing rdf:ID="Mustang"/>
<owl:Thing rdf:about="#Mustang">
<rdf:type rdf:resource="http://www.example.org/library#Mustang"/>
<owl:Restriction>
<owl:onProperty rdf:resource="
http://www.example.org/library#hasAsManufacturer"/>
<owl:hasValue rdf:resource="#FordCompany"/>
</owl:Restriction>
</owl:Thing>
<owl:Thing rdf:ID="Scorpio"/>
<owl:Thing rdf:about="#Scorpio">
<rdf:type rdf:resource="http://www.example.org/library#Scorpio"/>
<owl:Restriction>
<owl:onProperty rdf:resource="
http://www.example.org/library#hasAsManufacturer"/>
<owl:hasValue rdf:resource="#FordCompany"/>
</owl:Restriction>
</owl:Thing>
<owl:Thing rdf:ID="FordCompany"/>
<owl:Thing rdf:about="#FordCompany">
<rdf:type
rdf:resource="http://www.example.org/library#CarManufacturer"/>
<isManufacturerOf rdf:resource="#Mustang"/>
<isManufacturerOf rdf:resource="#Scorpio"/>
</owl:Thing>
<owl:Thing rdf:ID="myMustang"/>
<owl:Thing rdf:about="#myMustang">
<rdf:type rdf:resource="#Mustang"/> <!-- or is it allowed to type
this directly with http://www.example.org/library#Mustang ? -->
<hasAsManufacturer rdf:resource="#FordCompany"/>
</owl:Thing>
...
####################################################
The thread went as follows:
####################################################
Hans Teijgeler:
-----------------
I am still not 100% certain how to model the following:
- Ford Company isManufacturerOf Mustangs
- Ford Company isManufacturerOf myMustang
It seems that in both cases the same code is used, but I may be totally
wrong.
Dick McCullough:
--------------------
FordCompany isManufacturerOf Mustangs
myMustang rdf:type Mustangs
Hans Teijgeler:
-----------------
No, that is not what I want. I need to see how the code for both triples
looks like.
Dick McCullough:
--------------------
# Ford Company isManufacturerOf Mustangs
# Ford Company isManufacturerOf myMustang
<owl:Property rdf:ID="isManufacturerOf">
<rdf:domain rdf:resource="#Company"/>
<rdf:range rdf:resource="#CarBrand"/>
<rdf:range rdf:resource="#Car"/>
</owl:Property>
<Company rdf:ID="FordCompany"/>
<CarBrand rdf:ID="Mustangs">
<rdfs:subClassOf rdf:resource="#Car">
</CarBrand>
<Car rdf:ID="myMustang"/>
<rdf:type rdf:resource="#Mustangs"/>
</Car>
<FordCompany> <isManufacturerOf> <Mustangs/>
<FordCompany> <isManufacturerOf> <myMustang/>
Dick McCullough:
--------------------
common super class (lub) is Car. The hierarchy is Car / Mustangs
(CarBrand)
// myMustang
So property should be declared as
<owl:Property rdf:ID="isManufacturerOf">
<rdf:domain rdf:resource="#Company"/>
<rdf:range rdf:resource="#Car"/>
</owl:Property>
Then OWL allows using a subClass (Mustangs) of Car or an instance
(myMustang) of Car as an object ???
Valentin Sauerkraut:
------------------------
"Multiple domains mean that the domain of the property is the intersection
of the identified classes (and similarly for range)."[1]
So imho you created a property whose range consists of things that are of
type CarBrand AND of type Car.
. . .
This implies
that both Mustangs and myMustang are of type Car and of type CarBrand.
The easiest solution in this case is propably to specifiy the range of
isManufacturerOf as some common superclass of both car and carBrand.
Hans Teijgeler:
-----------------
To me it seems that:
- both triples can only exist in the RDF world
- Mustangs is the extent (in RDF) of an owl:Class Mustangs
- Mustang is typed with Mustangs
For the latter I don't know what the object of that rdf:type is, the
owl:Class or the RDF extent of it.
Jos DeRoo:
-----------
:isManufacturerOf rdfs:domain :Manufacturer; rdfs:range :Car.
:Mustangs rdfs:subClassOf :Car.
:FordCompany :isManufacturerOf :myMustang.
:myMustang rdf:type :Mustangs.
Hans Teijgeler:
-----------------
I came with this question because in our ISO 15926 modelling team we have
been puzzled by this for some time. Ford Company and myMustang are
individuals in space-time, the Class "Mustangs" isn't.
If I have understood RDF and OWL well, Ford Company and myMustang are in
defined in RDF, and the Class "Mustangs" is defined in OWL (as a subClassOf
Car). That creates a kind of "cross-over" Property isManufacturerOf between
the RDF domain (Ford) and the OWL domain (Mustangs) that is not allowed.
So, we create an owl:Thing "Mustangs" that is typed with the owl:Class
"Mustangs", and is the "extent" of that Class. Right? Now we need to create
the owl:Property isManufacturerOf, as Dick has illustrated below. However,
defining an intersection in RDF is not allowed. myMustang isn't a Class.
PS to Dick: CarBrand is different from what I meant with Mustangs.
Hans Teijgeler:
-----------------
The question is: how do I represent the information that FordCompany
isManufacturerOf Mustangs i.e. how do I define that Property?
Jos DeRoo:
-----------
My take would be to use a rule:
{?M :isManufacturerOf ?C.
?C rdf:type ?B}
=> {?M :yourProperty ?B}.
so that from
:FordCompany :isManufacturerOf :myMustang.
:myMustang rdf:type :Mustangs.
it follows that
:FordCompany :yourProperty :Mustangs.
Geoff Chappell:
------------------
:Mustangs rdfs:subClassOf
[
a owl:Restriction;
owl:hasValue :FordCompany;
owl:onProperty [owl:inverseOf
:isManufacturerOf]
]
Benjamin Nowack:
----------------------
>The question is: how do I represent the information that FordCompany
>isManufacturerOf Mustangs i.e. how do I define that Property?
hm, I'm probably stating the obvious, but I think it comes down to the
attempt to mix instance data with onto data, which is not so easy with the
basic OWL/RDFS axioms (of course, every subject/object in a triple can be
considered an instance, but I hope it's clear what I'm trying to say). So,
the basic means to specify a property are domain and range which expect
ontological constructs such as property or class as subject or object
respectively. That's why it's to intuitive to use them to say something
about #FordCompany, an individual.
One OWL construct I can think of atm which links ontological things to
individuals are "hasValue" property restrictions, but they require the class
to be the subject (in your example above #Mustangs is the object). What you
could perhaps describe is an inverse of isManufacturerOf, which could then
be used in such a property restriction (sorry for probaly broken syntax):
[[
#hasManufacturer owl:inverseOf #isManufacturerOf .
#Mustangs rdfs:subClassOf [
rdf:type owl:Rescriction ;
owl:onProperty #hasManufacturer ;
owl:hasValue #FordCompany ].
#Mustangs rdfs:subClassOf [
rdf:type owl:Rescriction ;
owl:onProperty #hasManufacturer ;
owl:cardinality 1 ].
]]
So, whenever a reasoner encounters a #Mustangs individual, shouldn't it be
able to deduce the manufacturer to be #FordCompany?
Not really thought through, may well be that #hasManufacturer has to be
functional or that it doesn't work at all. But "hasValue"
restrictions could be a way to get closer to what you are trying to model
without the need for custom rules.
just an idea,
Jos DeRoo (response to Geoff):
----------------------------------
True, that should do it and I was too much thinking about chained
properties, such as :uncle :-)
Geoff Chappell:
------------------
Or more directly (though not as strong):
:FordCompany rdf:type [a owl:Restriction;
owl:onProperty :isManufacturerOf;
owl:someValuesFrom :Mustangs]
####################################################
_____
ORIGINAL QUESTION
_____
From: semantic-web-request@w3.org [mailto:semantic-web-request@w3.org] On
Behalf Of Hans Teijgeler
Sent: Friday, October 14, 2005 7:11 PM
To: semantic-web@w3c.org
Subject: Mustangs vs myMustang
Hi,
I am still not 100% certain how to model the following:
- Ford Company isManufacturerOf Mustangs
- Ford Company isManufacturerOf myMustang
It seems that in both cases the same code is used, but I may be totally
wrong.
I'd appreciate some enlightment.
Regards,
Hans
_______________________
Hans Teijgeler
ISO 15926 specialist
<http://www.InfowebML.ws> www.InfowebML.ws
<mailto:hans.teijgeler@quicknet.nl> hans.teijgeler@quicknet.nl
phone +31-72-509 2005
Received on Sunday, 16 October 2005 11:20:10 UTC