# Re: slotted notation -summary

From: Christian de Sainte Marie <csma@ilog.fr>
Date: Tue, 09 Jan 2007 15:16:00 +0100
Message-ID: <45A3A3A0.1010107@ilog.fr>
To: Michael Kifer <kifer@cs.sunysb.edu>
CC: "Public-Rif-Wg (E-mail)" <public-rif-wg@w3.org>
```
Michael Kifer wrote:
>
>  [...]
>
> Different slotted styles
> ------------------------
> We can distinguish at least 2 styles of slotted notation: relational and
> object-oriented.

At least for those two ones, isn't it the case that a slotted predicate
of the OO kind can always be represented as a conjunction of binary
slotted predicates of the relational variety, where the predicate
represents the slot/property/attribute, one of the roles is the object
(e.g., the first, by convention), and the other one is the value?

> Object-oriented slot notation:
>           This semantics is used in F-logic, RDF, etc., and can also be
>           simulated by choosing the appropriate constraints for OSF.
>           Again, there are two things that one might say about slots in
>           F-logic (and RDFS):
>
> 	  p(slot1->val1,...,slotn->valn)
> 	        Here p is an object (as opposed to relation) and
> 		slot1(p)=val1, ..., slotn(p)=valn.

That is, couldn't that be, by convention (in RIF):
slot1(p, val1) and ... and slotn(p, valn)?

I may be naive, but I did not see in the discussion anything that could
not be handled that way (except maybe for RDF bNodes).

So, why not have the closed relational slotted notation in RIF Core, and
some convention for transforming OO slotted predicated into that
notation (same kind of process as the one to bring an OSF term into its
solved form)? (*)

I am aware that that solution might have an impact on roundtrips (and,
thus, on efficiency in specific rule engines; readibility in specific
target rule languages etc), but that would be an argument in favor of
having data-model specific dialects, rather than having two different
notations (**) for the same thing in RIF Core.

On the other hand, if the two notations (**) are not equivalent, and if
there is no single notation (with a single semantics) that can account
for both kind of slotted syntaxes (***), we should probably not have
slots in RIF Core (that is, Michael's option 4).

(*) that would not imply a closed-world assumption, if I am correct.

(**) 1) n-ary slotted predicate where the predicate is actually the
object; 2) binary slotted predicates where the predicate is the
attribute, and the arguments the object and the value.

(***) what other semantics are there for slotted syntaxes? How do they
relate to the relational and OO ones?

Christian
```
Received on Tuesday, 9 January 2007 14:15:21 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:47:41 UTC