W3C home > Mailing lists > Public > public-owl-dev@w3.org > January to March 2008

RE: Xtreme Punning

From: Gerd Wagner <wagnerg@tu-cottbus.de>
Date: Fri, 11 Jan 2008 21:55:22 +0100
To: "'Pat Hayes'" <phayes@ihmc.us>
Cc: "'Denny Vrandecic'" <dvr@aifb.uni-karlsruhe.de>, "'Jeremy Carroll'" <jjc@hpl.hp.com>, "'Owl Dev'" <public-owl-dev@w3.org>
Message-ID: <000001c85494$494a53c0$19b2a8c0@informatik.tucottbus.de>

> >In the first case, the thing denoted by the first occurrence
> >of Dog is the same thing as the thing denoted by the second
> >occurrence of Dog, namely the class Dog, which happens to be
> >an instance (not really an "individual" in the strict sense
> >of a thing that has no instances/extension).
> >
> >In the second case, the thing denoted by the first occurrence
> >of Father is a property, while the thing denoted by the second
> >occurrence of Father is a (role) class. Clearly, these two
> >things are closely related to each other, but they are not
> >the same.
> 
> In the RDF/RDFS/OWL1.0Full/CommonLogic/Hilog semantics, they are the 
> same 'thing'. That is, there is one thing denoted by the name, which 
> has both a class and a property extension. The two extensions are 
> distinct mathematical entities, of course, but the semantics insists 
> that each name denote a unique entity. 

OK, so formally one can treat the property "Father" and the (role)
class "Father" as the same thing, and such a naming convention 
may indeed be an option. However, I guess, it seems more natural
for many people (like Jeremy) to distiguish the two and rather
use different names such as "father" and "Father".

> >Another important case of the same thing appearing in two
> >different forms (or sntactical categories) are functional
> >properties which can appear both as property predicates and
> >as function symbols (though not in OWL).
> 
> Ah, now there I disagree. KIF used this, but we abandoned it in CL. 
> The problem is that in order to use it, a convention has to be 
> adopted (and built into the syntax) about which relational argument 
> is the 'value' of the function. This amounts to an arbitrary 
> non-logical convention being made part of the logic, which invariably 
> causes confusion: and indeed, there are systems out there already 
> using both conventions (value first/value last). Also, speaking 
> strictly, a function is not actually *identical* with a functional 
> relation. So in CL we left the relationship between R with two 
> arguments and R with one argument entirely open, and require users to 
> axiomatize their preferences explicitly, for example
> 
> (forall (r)(iff (FunctionalBinaryRelation R)(forall (x)(R x (R x))) ))

OK, this looks like a reasonable approach to me.

I was just going to point out that, given the "duality"
of purely relational (Datalog-style) languages, such as OWL, 
and purely functional languages, such as OCL, and the need 
to be able to translate or switch from one to the other, 
it seems useful to adopt a view where we have functional 
properties (such as "father") which may show up as predicates
such as in the OWL fact 

	father(Zeus,Aphrodite) 

or as function symbols, such as in the OCL equality 

	Aphrodite = Zeus.father

where the path expression "Zeus.father" stands for the
function term "father(Zeus)".

-Gerd
Received on Friday, 11 January 2008 20:55:47 GMT

This archive was generated by hypermail 2.3.1 : Wednesday, 27 March 2013 09:32:55 GMT