# Re: Alternatives to containers/collections (was Re: Requirements for a possible "RDF 2.0")

```On Jan 14, 2010, at 3:49 PM, Frank Manola wrote:

>
> On Jan 14, 2010, at 3:19 PM, Pat Hayes wrote:
>
>>
>> On Jan 14, 2010, at 11:31 AM, Dan Brickley wrote:
>>
>>> On Thu, Jan 14, 2010 at 4:20 PM, Pat Hayes <phayes@ihmc.us> wrote:
>>>> A lot, perhaps all, of this hair could be avoided if RDF allowed
>>>> general
>>>> tuples as well as triples. All that is needed is some way to put
>>>> N things
>>>> into a sequence: so, put N things into a sequence. The 'graph
>>>> model' would
>>>> be a hyperlink, drawn as a polygon (eg triangle for N=3) rather
>>>> than a line.
>>>> In triples-style syntax, it would just be moving a dot.
>>>
>>> I periodically wonder what an RDF without the binary restriction
>>> would
>>> look like.
>>
>> My 2c suggestions, as answers to the questions.
>>>
>>> Would each property/relation have a fixed arity, eg. dc:source might
>>> 'be a 4', 'foaf:knows' a 7?
>>
>> No. But it might be useful to distinguish 'really binary' ones,
>> which only fit in triples, from the others, which can take any
>> number of things in the sequence. Or maybe not, whatever. But the
>> default should be, any number (even though most of them will be 2
>> in practice, ie triples.)
>>
>>> That doesn't make a lot of sense to me. So
>>> presumably they'd vary freely. In which case, we have a lot of
>>> figuring out to do when wondering whether   livesWith(alice, bob,
>>> 2007, 'y') implies livesWith(alice,bob) or livesWith(alice, bob,
>>> 'y',
>>> 'foo.html'). The binary straightjacket makes some of these questions
>>
>> The Common Logic answer is very puritan: each number of arguments
>> is a separate assertion, and they are all independent (unless you
>> write axioms connecting them.) So liveswith(a b c) has nothing to
>> do with liveswith(a b) or with liveswith(a b c d), etc., as far as
>> the logic itself is concerned.  This is actually quite elegant and
>> works well WHEN you can write the axioms you might need. So maybe
>> we would need, for RDF, some way to attach some common inference
>> patterns to these by giving properties to the property of the
>> tuple. For example, one useful and common pattern allows ends of
>> argument lists to be lopped off, so that
>>
>> entails
>> liveswith(alice, bob)
>>
>> and we might specify this pattern (in a semantically extended RDF)
>> by asserting
>>
>> liveswith rdf:type rdf:ExtendableProperty .
>>
>> But this is very much off the top of my head. Whaddayathink?
>
> Pat--
>
> Could you carry this Common Logic example a bit further?  Suppose we
> have the tuple
>
> liveswith(alice, bob, "4255 18th Street NW, Washington, DC",
> "married")
>
> In the relational data model, I might have declared the relation
> "liveswith" as having columns "wifename", "husbandname", "address",
> and "maritalstatus", so I know how to interpret the various
> arguments of the tuple.  But how do I make this association (e.g.,
> between the third argument of the tuple and "address") if I
> encounter this  tuple "in the wild" of the semantic web?

If all you have is the tuple, you just have to know. I agree, this is
more of a problem with info in the wild. So for things like this,
essentially argument sequences, I think in fact its better to encode
it using binary relations with 'role names' as you outline. However,
this idea has been around for 25 years or more, and still RDF people,
and even quite sophisticated OWL folk, seem to often have trouble with
it.

>  How does Common Logic deal with this?

It doesn't. That is, it *allows* the case/role style using all binary,
of course, but it doesn't have any special syntax for it. (It did
once, but we took it out as being too complicated and nobody seemed to
want it, in fact.)

> This may be a confession of ignorance of something really basic, but
> this issue, to me, was always one of the reasons for favoring a
> purely binary approach.  You always knew what the various parts of
> the triple signified, without having to go off and find some other
> declaration somewhere.

Its a good point, and its why I (a logician) always was cool with a
purely binary RDF. But the fact is that many folk seem to want to
string things together, and tuples are a lot simpler than linked list
S-expressions written using triples.

Pat

>
> --Frank
>
>
>

------------------------------------------------------------
IHMC                                     (850)434 8903 or (650)494 3973
40 South Alcaniz St.           (850)202 4416   office
Pensacola                            (850)202 4440   fax
FL 32502                              (850)291 0667   mobile
phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes
```

Received on Friday, 15 January 2010 06:14:45 UTC