Re: Tentative contribution to the "URI issue"

RIFers:

This is a response first to Francois, then Jos, then Hassan.
Sorry for putting all these together, but these things are related.
The msg is kind of long.


	--michael  



Part 1: Francois

Neither of the two issues you (Francois) mentioned in the message attached
at the end is an issue that we are grappling with.

In fact, those things have already been settled in WD1 consistently with
what you wrote (choosing option 1 for the second issue).  It is **obvious**
that a URIs should be an individual in RIF logic (or a function symbol, or
a predicate symbol, or all three, if needed). There is nothing left to
discuss here.

Let me skip the issue of why we use sorts, as it has been discussed quite
extensively since December, and seems to have been settled.

Today's discussion arose out of Jos' question of WHY DO WE NEED A SORT FOR
URIs and NOT out of a misunderstanding of what is a URI from the logical
point of view. (I am using the capitals to emphasise, not to scream :-)

So, here is the issue at its clearest, I hope.

We need a syntax (abstract, concrete, shmoncrete - you name it)
for individuals and other things.\footnote{
     The issue has nothing to do with the "kind" of syntax we choose.
     So, by going into the abstract syntax, as Dave R suggested, the issue
     doesn't go away.
}

In a textbook, the author just writes a, b, c, X, and people go on to more
important things. But we are specifying a concrete language based on a
logic, so we need to be precise how individuals are written using character
sequences.

On top of this, we have a requirement to have a special type of individuals
(pred symbols, func symbols, etc.) that are these strange beasts called "URIs".
What is a URI? It is something like http://francois.com/bry or
mailto:kifer@foo.bar, or urn:123:456, or ...

In addition, we have integers like 123, times like 23:44:55.12345,
date/times like 2000-01-02T21:22:23.5432-10:30, and even stranger things.
And we don't want to confuse 2000-01-02T21:22:23.5432-10:30 for a string
and a URI of the form urn:23:44:55 as having anything to do with time.

Now, should we just allow to write these things as they are?
For instance, is it fine to write something like

   .... ?X is 2000-01-02+1 ...

Does it mean a number 1998 or a date 2000-02-03 or a string 2000-01-02+1?

What does http://bry@francois.com/salary.add(E10000) mean?  Is it an
application of the method "add" to the string
http://bry@francois.com/salary and the result is the string
http://bry@francois.com/salaryE10000 or it is a result of an application of
the method "add" to the object *denoted* by the URI
http://bry@francois.com/salary (which could denote your salary and mean a
nice 10K raise for you)?

So, we need a mechanism to say that a particular thing is an apple even
though it may look like a pear, and that some other thing is a clementine
even though it looks like an orange.  That is (tipping my hat to Dave),
whether the above stuff as a string:
"http://bry@francois.com/salary"^^string
or a URI:
"http://bry@francois.com/salary"^^uri.

This is where sorted literals come in. I hope this is clear.

Part 2: Jos

The question is how does one differentiate URIs from strings.
Are they strings? Should they be? If all we (collectively) want
is to write "http://jos@debrujin.com/salary"("2020-11-22", "E100000")
where "..." are strings, then there is no problem.
But I don't think think this is what we collectively had in mind.
I believe we wanted to distinguish URIs from strings and other types of
constants.

There is also an issue of signatures when we will start allowing or
disallowing certain individuals to play roles of predicates, functions,
etc.  We cannot assign a signature to any given constant, so sorts could be
one of the grouping mechanisms here. For instance, if a dialect (like, say,
WSML) allows only URIs to be concepts then only the constants of the sort
rif:uri will have Boolean signatures.

Maybe sorts cannot serve as the only such grouping mechanism, but they are
a good way to start.

Part 3: Hassan

Now, to answer what I think was Hassan's issue with using URIs both as sort
names and constants of a particular sort, let's again choose Dave's
favorite notation: "literal"^^sort.

As far as I understand, the problem that you (Hassan) correctly foresaw was
this.  Let's suppose we have a date-time constant 2002-02-02T12:33:44. If
its sort is a RIF URI "http://www.w3.org/2001/XMLSchema#dateTime"^^rif:uri
then the above dateTime thing will look like this:

"2002-02-02T12:33:44"^^"http://www.w3.org/2001/XMLSchema#dateTime"^^rif:uri

Something weird. And, of course, rif:uri is a sort, so it should expand to

"http://www.w3.org/2005/rules/datatypes#uri"^^rif:uri

or some similar crap. And so on.

But this is not what the current WD1 does. Sorts are separate symbols, not
rif:uri constants. So, if you want to use URIs as sort names, you write

"2002-02-02T12:33:44"^^"http://www.w3.org/2001/XMLSchema#dateTime"

or "2002-02-02T12:33:44"^^'http://www.w3.org/2001/XMLSchema#dateTime'

or "2002-02-02T12:33:44"^^xsd:dateTime

or "2002-02-02T12:33:44"^^foobar

(or whatever we finally settle on). But keep in mind that foobar here is
used to denote a sort and has nothing to do with a constant
"foobar"^of-some-sort.


Epilogue

Hope this makes things clear(er).



> Dear All,
> 
> Let me attempt to clarify an understanding of the URI issue - hopefully
> shared by others.
> 
> URI can be used in a logic language, like in other web formalims, as
> unique indentifiers of ... whatever. This way, one can have formulas like:
> 
> forall x http://example.com:father(http://bry.name/francois, x) =>
> http://example.com:has_family_name(x, bry)
> 
> with the meaning that all my children have the family anme "bry"
> (assumption). The URIs are no more than symbolic references. This way,
> uri1:p can be a n-ary predicate symbol and uri2:p can be a predicate
> symbol distinct from uri1:p. Such a use of URI does not call for much
> changes in the definition of syntax and semantics of a logic language. A
> bit of care would suffices, I believe.
> 
> Another use of URI in a logic language would be like in the slightly
> modified following formulas (the modification is at the end of the
> formula):
> 
> forall x http://example.com:father(http://bry.name/francois, x) =>
> http://example.com:has_family_name(x, http://example.com:bry)
> 
> Now, the (individual) constant in the formula  is a URI. I see two ways.
> Either, a URI-constant is a constant like any other. In this case, it is
> interpreted (by the appropriate I function of the
> interpretation/structure considered) as an element of the domain.
> Nothing needs to be changed in the semantics. Or, instead, it is a
> special constant that can only be interpreted in a special way, i.e. by
> specific elements that must belong to the domain.
> 
> Such special interpretations for specific constants is nothing new in
> logic. In classical methematical logic, as well as in all logic-based
> computational languages, integers as well as other kinds of numbers are
> interpreted in a specific way, namely, 12 is *required* to be
> interpreted by the 13. integer following 0 and nothing else. (Note that,
> in the generall setting of WD1 Core's semantics, such an interpretation
> of integers is *not* required.). Such specific interpretationas are also
> used in language with equality: only so-called "normal interpretations"
> are usually considered thst interprete the equality symbol in ther
> language by equality in the interpretation.
> 
> The restriction to so-called "standard interpretation" interpreting
> integers - and more generally numbers - in the (expected) specific way
> has two good reasons, a theoretical and a practical one. First, the
> natural numbers with elementary arithmetics cannot be fully axiomatized.
> All axiomatizations are satisfied by strange things that are similar -
> but different - from the natural number with elementary arithmetics.
> Second, if reasoning is to be performed - by machines or humans -, then
> "short cuts" are necessary for avoiding lenghty and complicated proofs
> that would results from using axioms for natural numbers and
> arithmetics. These short cuts are exactly what one might think of: 12 +
> 3 is computed in some efficient manner yielding 15 instead of using
> reasoning on  axioms for getting the same result.
> 
> I think, the first use mentioned above of URIs is no problems. All we
> need is a careful phrasing. The second use of URIs - and for thanrt
> matter of numbers - require instead to modify the semantics so as to
> ensure that URIs - and numbers - are interpreted as they should.
> 
> The question is, of course, how should URI be interpreted?
> 
> I think,  it suffices to add a no further specified non-empty set of
> resources to the domain over which URIs are interpreted. I believe, no
> more is needed. Eg there is no need to require the set of resources to
> be disjoint from the remaining domain or to require two distinct URIs to
> be interpreted by two distinct resources. Also, there is no need to
> define what is a resource.
> 
> I hope, this helps... If I am missing something, please, let me know!
> 
> Regards,
> 
> Francois

Received on Tuesday, 20 March 2007 20:35:20 UTC