W3C home > Mailing lists > Public > semantic-web@w3.org > July 2005

RE: UBL Naming Conventions & RDF

From: John McClure <jmcclure@hypergrove.com>
Date: Sat, 9 Jul 2005 13:07:48 -0700
To: <semantic-web@w3.org>
Message-ID: <MGEEIEEKKOMOLNHJAHMKGEEJDOAA.jmcclure@hypergrove.com>

Thank you for the  responses. I read the group charter today and of your
interest in applying RDF to eCommerce -- this is great and suggests UBL and RDF
could be stitched together. Please pardon the longish reply.

Jonathon Brinley said the "class of the object says nothing about the
relationship that holds between the subject and the object" ... Let me sketch a
pertinent model that follows a best practice I said earlier, that all predicate
nouns are qualified nouns.

<owl:Class rdf:ID='Noun'>
      <rdfs:subClassOf rdf:resource='http://www.w3.org/2002/07/owl#Class'/>
<owl:Class rdf:ID='DirectObject'>
      <rdfs:subClassOf rdf:resource='#Noun'/>
<owl:Class rdf:ID='Verb'>
<owl:ObjectProperty rdf:ID='has'>
      <rdf:type rdf:resource='#Verb'/>
      <rdfs:range rdf:resource='#DirectObject'/>
      <rdfs:domain rdf:resource='#Noun'/>
<owl:Class rdf:ID='Person'>
      <rdf:type rdf:resource='#Noun'/>
<owl:Class rdf:ID='Acquaintance'>
      <rdfs:subClassOf rdf:resource='#Person'/>
<owl:ObjectProperty rdf:ID='PersonalAcquaintance'>
      <rdf:type rdf:resource='#DirectObject'/>
      <rdf:type rdf:resource='#SymmetricProperty'/>
      <rdfs:range rdf:resource='#Acquaintance'/>
      <rdfs:domain rdf:resource='#Person'/>

And some instances....

<Person rdf:ID='X'>
         <PersonalAcquaintance rdf:ID='Z1' rdf:about='Y'/>
<Person rdf:ID='Y'>
         <!-- Z2 can be inferred from Z1 -->
         <PersonalAcquaintance rdf:ID='Z2' rdf:about='X'/>

>From the definition of PersonalAcquaintance, a reasoner infers that Y 'has' a
PersonalAcquaintance who is X since it is a symmetric property. Same as today
for a 'hasAcquaintance' or 'knows' property. The DirectObject metaclass for
PersonalAcquaintance gives the same capabilities had today for expressing
instance relationships (and to infer information) because a DirectObject is a
subclass of both Noun and ObjectProperty. I hope this responds to your concern
that the "class of the (direct?) object says nothing about the relationship that
holds between the subject and the (instance?) object"... [also, note that Z1 is
an instance of a relationship between the Subject and PredicateNoun in effect
giving an identifier to the predicate -- all of these relationships ultimately
inherit from a root 'RelatedResource' property defined for an "Associable" class
that is inherited by classes of substance (person place or thing classes).]

I am not sure how the graphs would be drawn with this level of granularity, but
it would be interesting to hear about it.

Frank Manola:
>Also, while RDF uses the term "predicate", I don't think that should be
>interpreted very literally as meaning quite the same thing that English
>grammar means by "predicate".  Perhaps I'm missing your point?

The RDF models a "data structure" such as standardized by ECMA languages, which
could be said as: 'object-has-property-has-value(s)'. The RDF establishes the
'object' part as a subject, and all the rest as a predicate.... same as English
grammar ... and deals with text vs object 'value(s)'... and includes C++-like
taxonomy support . In effect I suggest decomposing the "predicate part" into its
fundamental constituents, e.g., into predicate verbs, predicate nouns (as direct
or maybe indirect objects), qualifiers, and maybe prepositions. Exploiting this
level of metadata leads to higher quality ontologies.

>Some of the example properties they define include "predicate verbs"
>(hasWineDescriptor, hasColor) and some don't (madeFromGrape, course).

Within "madeFromGrape" is the predicate verb "made" I think! But I wouldn't
recommend "madeFrom" instead opting for "a Wine has a PrimaryGrape property",
whose range is a VarietalGrape, and whose name is significantly more potent than
merely "madeFromGrape".

I still believe the schema authors at http://www.schemaweb.info have 100%
absorbed the idea that the RDF convention for predicates is to have a verb+noun,
sometimes with a preposition thrown in for clarity's sake....  I guess rdf:type
is the only exception noted so far.

Damian Steer:
The architectural justification for 'has' stems from adoption of the
'object-has-property-has-value(s)' model. FWIW, the verb 'has'  is "to have or
possess (in the present tense)" [edited Word Net]. But more interestingly, I
think that the temporal quality associated with every relationship between
resources should be of key importance. I am suggesting that 'has' is not a
flaccid connector but is part of a group of subclasses of the verb "have", one
including "hasNot", "had", "hadNot", "willHave", and "willHaveNot". I believe
that "may" and "should" functions should be included. Note that WITHOUT this
approach, an ontology might have both "hasAcquaintance" and "hadAcquaintance"..
what a mess.

><Person><has><Grandparent rdf:about='uri' ... ?
>A grandparent is a parent, so does this say the person named 'uri' is
>the grandparent or the parent of the first person?
>Ditto for the foaf:knows suggestion.

I agree that a Grandparent is a Parent, but the name specified is as a
Grandparent. But applying the rule from above about predicate nouns being
qualified nouns, yields <Person><has><CloseRelative> with an rdf:type indicating
a Grandparent (or via a property like RelativeType). Here's a good example of
why the rule exists: A Person can BE a Grandparent, but can never HAVE a
Grandparent. Instead, a Person HAS a CloseRelative who IS a Grandparent... This
approach sorts out the distinction between two different (verb) properties,
"has' and 'is' -- 'has' takes a DirectObject and 'is' would take a Class as a
range. [Note, I don't like 'is' at all, and instead opt for "has SomeType"] I
also think this approach is more efficient and informative than a hasGrandparent
property, because the ontology could have <FarRelative> as an antithesis which
forces a user to provide an additional very potentially useful bit of
information, whether the grandparent is close to the person or not. Finally, let
me note that the whole DirectObject approach allows a set of properties (and
rdf:type) to be specified for a predicate, a feature simply unavailable under
conventional RDF.

I hope the question about foaf:knows is answered by the discussion of
PersonalAcquaintance above.... it seemed that if A is a personal acquaintance of
B then B is also for A, so <owl:SymmetricProperty/> is in the definition above,
as it would be for 'knows'.

A DirectObject is a subClassOf both ObjectProperty and Noun. This means a
DirectObject can have both subClassOf and subPropertyOf properties.
'subPropertyOf' is used to indicate a functional (or narrowing) relationship
with another property. I'd be interested in ideas about how subClassOf should be
used. My thought has been that, for example, a "PrimaryGrape" would intersect
the "Primary" and the "Grape" classes, with the 'Primary' class being a
subClassOf of 'Ordinality' which is itself an instance of another metaclass,
called 'Quality' (essentially every entry in an ontology is tagged as to whether
it is a Noun, Verb, or Qualifier)... and it would be a subPropertyOf, say, a
"ConsituentMaterial" property defined for superclass "Product".
Received on Saturday, 9 July 2005 20:07:38 UTC

This archive was generated by hypermail 2.4.0 : Tuesday, 5 July 2022 08:44:53 UTC