Re: SUO: Re: W3C approves RDF and OWL as recommendations
Folks,
Could you elaborate on why separating roles and relations is a bad
thing? To be sure, if two notions can be combined, then that does indeed
improve sharing and reduce complexity, but only if that is not at the
expense of creating an incorrect formalization.
Parent is a transient role and thus has not been formalized as a class
in SUMO. If 'parent' were made a class 'Parent', then an individual's
class membership could change over time, which is a problem. This is often
the case for relations. It would make no sense for example, for the
'patient' role also to be a class, for the same reason. There are
pragmatic boundary cases to this issue, but the general approach to
representing transient characteristics in relations is fairly standard and
sound.
Adam
>I do not think that Asha's main point (if I understood it) has been
>answered. Given the additional precisions in http://www.eis.com.cy/
>I think that Asha is referring to the fact that each "role-related
>notions" such as "parent" (not the parenting process) may be represented
>by a relation type (e.g. parent) and/or a concept type (e.g. Parent),
>and that these two categories are exclusive (e.g. in the SUMO, parent
>would be abstract while Parent would be physical), thus leading to
>(i) an increase of the complexity of knowledge entering/management (since
>the notions have to be represented twice and then connected by definitions
>to permit inference engines to compare the representations using the
>relation types with the representations using the concept types), and/or
>(ii) a decrease in knowledge sharing/retrieval possibilities (this is
>actually the most likely outcome).
>
>As a partial solution, in Ontoseek and WebKB-2, certain role-representing
>concept types may be used in relation nodes, as in the following example
>in CGLF: [Person:Tom]->(Parent)->[Person:Mary]. In WebKB-2, the constraints
>are that Parent is a subtype of pm#thing_that_can_be_seen_as_a_relation
>and that Mary has been declared as instance of Parent. In Ontoseek, if I
>remember correctly, I think that Mary may simply be instance of Person
>if Parent has been declared has a role type and is a direct subtype of
>Person. Assuming that no relation type name parent exists in the ontology,
>to export the above representation into KIF, such a relation type should
>be generated and in its signature, the destination type should be Parent
>or Person. Then, the KIF representation could be: (parent Tom Mary).
>
>An extension of this approach that I will probably implement in the
>medium-term is to permit a signature to be associated to a concept type,
>e.g. specifying that if Parent is used as a relation, it must connect an
>instance of Animal to another instance of Animal. E.g. in the FT notation:
> Parent (Animal,Animal) < Animal;
>could be converted into the following in KIF+SUMO:
> (subclass Parent Animal) (instance parent binaryRelation)
> (domain parent 1 Animal) (domain parent 2 Animal)
> (=> (parent ?A1 ?A2) (Parent ?A2))
> (=> (Parent ?A2) (exists ((?A1 Animal)) (parent ?A1 ?A2)))
>
>Such a shortcut can also be used in KIF, e.g. by defining the relation
>roleTypeDomain in such a way that the following 3 formulas are equivalent
>to the 6 previous ones:
> (subclass Parent Animal)
> (roleTypeDomain Parent 1 Animal) (roleTypeDomain Parent 2 Animal)
>Yes, that would involve string manipulation but KIF can do that.
>
>A relation such as roleTypeDomain cannot be "defined" in RDF+OWL but it
>could be added as a primitive to OWL. That would address one of the points
>raised by Asha. However, in my opinion, that would not be sufficient for
>RDF+OWL to be an adequate language for knowledge representation and
>sharing since
>(i) there are still many important constructs (related to contexts,
>sets, and numerical quantifiers) that can only be represented in
>(very) ad-hoc ways or not at all (e.g. see the 2nd half of
>http://www.webkb.org/doc/model/comparisons.html
>i.e. starting from the section "contextualization"), and as John Sowa
>pointed out, it is not the role of a "knowledge sharing" language to
>reduce the expressivity, it is up to each inference engine to select the
>(parts of the) representations that it can use, and warn about the fact
>that it ignored some information (or advertize its capabilities, as in
>the OKBC protocol),
>(ii) the model and the adopted conventions are low-level (i.e. they
>lead users to represent the same thing in many different ways, many of
>which are uncomparable or very hard to compare automatically), prevent
>very important checks (e.g. subsumption link cycles are allowed because
>the used subtype links are not "proper subtype" links), and make the
>conversion/presentation of the RDF representations into high-level
>languages and controlled Englishs quite awkward,
>(iii) its XML syntax makes the detection of errors difficult (this
>syntax is not supposed to be seen but in practice it is, if only by
>researchers and those who develop RDF-related tools).
>
>Philippe