Entailment and bags (was:Re: Agenda items for the f2f)

>
>>  Agenda request: collections
>>	(esp. entailment stuff around bags. I have
>>	an idea I haven't written up yet...)
>
>+1
>
>The MT urgently needs this - collections are deployed.

Agreed. Let me summarize my own take on this, as I really think that 
this is the only rational possibility without making some very 
fundamental and far-reaching changes in the RDF model.

We have containers that have ordered selectors, ie the ordering is 
built into the very syntax of the selectors. So the containers simply 
*are* ordered in any RDF interpretation, whether we want to treat 
that order as significant or not. So we cannot make rdf:bags into 
unordered entities in the RDF model theory.

For more on this see (Sorry Im off-web so cannot give URIs) the 
thread "Bags (was: closing semantic issues)" starting 7 Nov 01.   Key 
excerpts:
<excerpt>
---------------------
DanC:
>         _:b rdf:type rdf:Bag.
>         _:b rdf:_1 "abc".
>         _:b rdf:_2 "def".
>
>entails
>
>         _:b rdf:type rdf:Bag.
>         _:b rdf:_2 "abc".
>         _:b rdf:_1 "def".
>
>and generally: the _n arcs of a bag can be permuted.

PatH:

That doesn't work. If it entails that, then it must also entail:

         _:b rdf:type rdf:Bag.
         _:b rdf:_1 "abc".
         _:b rdf:_2 "def".
         _:b rdf:_2 "abc".
         _:b rdf:_1 "def".

so just saying 'can be permuted' isn't enough. The fact is that we 
really shouldn't have indexed selectors on things that are supposed 
to be bags, since once you use those selectors once, the bag is 
ordered, whether you like it or not. You can only 'permute' it if you 
have state, and RDF has no states to permute over. Monotonic 
inference only adds conclusions, it can't do things like permutation.

Graham:
>
>I was thinking that a bag represented using a list-type expression 
>might have the same problem:

If you want it actually BE a bag, right, it will break. It cant be 
both a list and a bag. (It could be a list pretending to be a bag, 
though. Two different lists can pretend to be same bag, of course.:-)
---------------------
Pat H:
I've always understood the idea to be that RDF *describes* 
containers, rather than implementing them or exemplifying them. So it 
is OK for RDF to keep a 'private' ordering and basically treat all 
containers as sequences, but if it describes a container as being an 
rdf:Bag then it is saying that this ordering isn't supposed to be 
taken to be 'significant' in some sense. (I think this is close to 
what the M&S says.) But the ordering is still *there* in the RDF. 
After all, this is exactly how LISP would handle bags: you would 
encode them as lists and provide bag-access functions that pretended 
that the list ordering didn't matter, by doing things like checking 
for permutations under the hood. RDF doesn't implement this kind of 
thing, of course, but then that's not its role; it just has to carry 
information around without damaging it. If it delivers all the 
members of a container and the container type, that's all it needs to 
be able to do, right? Something else can figure out what to do with 
it from there on out.
----------------------
</excerpts>

I guess that sums it up. We cannot possibly (1) use ordered selectors 
to access elements of an unordered container, (2) use monotonic 
inference, and also (3) expect that the containers will be identical 
when the ordering is permuted, all at the same time. We have to give 
up on one of these. I suggest that (2) is more important than 
containers, that (1) is now a given, since this syntax is deployed 
even if it is brain-damaged, so we have to give up on (3). And also 
that this is not such a bad idea, if we document it properly. It 
amounts to saying that RDF really treats all containers in the same 
way (which it does) but is able to record - not use, but record - the 
information needed by any external applications that may worry about 
whether two containers are or are not distinct. Thats the difference 
between saying that container is a bag or a sequence: not that it 
'acts like' a bag in RDF reasoning.

If this is acceptable then it is trivial to add rdf:seq and rdf:bag 
to the MT. I've already written the relevant section. (Adding rdf:Alt 
to the MT is something else altogether: I would suggest that we 
simply abandon rdf:Alt.)

Pat

-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes

Received on Monday, 4 February 2002 14:30:50 UTC