Re: Example of applying sorted-nucleus? was Re: [TED] CORE Pages on Positive Conditions and Horn Rules Edited: Slots & Constraints

[I think this thread is winding down now in any case, but this is my 
last post of the year and I'll be out of contact until next year. Happy 
holidays to all!]

Michael Kifer wrote:

>> This was at the heart of why I was confused first time around. To me 
>> "webizing" is about how you spell things like variable-names and 
>> procedure-names, and not to do with the type system that constrains the 
>> types of variables or the signatures of procedures.
> 
> I think webizing means the use of IRIs as global identifiers for constants,
> properties, and concepts. Because the same symbol (IRI) can be used in all
> these different contexts (and some other symbols, like integers may not be
> allowed to be used in some contexts), 

Well the symbol isn't necessarily the bare IRI itself. One could have 
symbols in which the IRI is but a part of the token so that property:iri 
and constant:iri could be syntactically distinct symbols, identifiable 
locally without any recourse to any separate signatures.

 > it is necessary to have one domain
 > and also some rules to specify which combos of syntactic elements are
 > allowed and which are not. This is essentially the main use of
 > multi-sorted languages.

Is that necessary?

In RDF, for example [*], the syntax is very permissive. This is possible 
because in the model theory a single domain element can be both a 
constant, a property (have a property extension) and a class (have a 
class extension) so we avoid having to make any syntactic distinctions 
at all between those things. When we do have to make syntactic 
distinctions (specifically, typed literals) they are designed to be 
self-describing. This permissive, schemaless, self-describing, nature is 
a key to its value in many of our applications.

Then for specific applications we create vocabulary elements and define 
their semantic structure in OWL but all that is at the semantic level 
and the syntactic language remains common.

I guess I was hoping for RIF core to be somewhat similar - a general 
purpose core syntax with few restrictions where dialects introduce 
symbols with dialect-specific semantics but don't need to modify the 
language syntax - more like lisp than pascal.

I guess the counter argument is that that that might be OK for the core 
but some dialects will want stronger syntactic constraints and so a 
syntactic constraint mechanism is needed.

The counter to that counter is that it is hard to do that in a way that 
supports forward compatibility.

>> I guess this isn't a problem in RDF because the interpretation of foo^A 
>> and foo^B will be identical - the lexical-to-valuespace map will map 
>> each onto the same valuespace element - and in RDF it's only the 
>> interpretation we care about.
> 
> Which basically means that RDF has an implicit equality theory in which
> foo^A = foo^B if A is a subtype of B.  But for an extensible (and much
> richer) family of rule languages, like RIF, this is not good enough. One
> needs more general means of specifying sorts and domains.

I think it is more because this is semantic equality and that's all we 
care about in RDF, see above discussion. Then we have the full power of 
OWL for specifying semantic structure such as equality.

> In the language one asks questions like "is this particular constant (IRI,
> for example) a member of the class owl:Thing?" The answer is always yes
> because every constant is interpreted as a member of the domain of
> interpretation, and owl:Thing is, by definition, interpreted by the set
> that equals the entire domain.

Minor point, but see discussion with Harold, owl:Thing is only the 
entire domain in the case of OWL/full, for OWL/DL it is a strict subset.

---

I wonder if the next stage is to find a way to ground this. Can the 
working group come up with a specific test case of a RIF dialect that 
needs to extend the core in a simple but somewhat representative way? 
Then we could work through the details of precisely how that extension 
is done.

Dave

[*] I realize that RDF is not a primary concern of RIF and that I sound 
like a broken record on it but (a) it helps me to base the discussion on 
something I understand which seems to have taken a different course and 
(b) we are chartered to end up with something somewhat RDF-compatible :-)

Received on Thursday, 14 December 2006 10:57:45 UTC