Re: What is the most common type of collection or container?

Patrick - you couldn't be more right about the fact
that inconsistencies could occur. The OWL testsuite
illustrates that with 80 cases of InconsistencyTests
(2 among them being rdf:List related).
One point is that one can try to detect those
inconsistencies. Something else is resolving them.
There are ways to do such things (for instance
"check your premises" leading to graphs that
you have assumed to be the case, but which aren't
and then you can choose but choosing is not global).

Jos De Roo, AGFA

                      Patrick Stickler                                                                                                 
                      <patrick.stickler        To:       Jos De_Roo/AMDUS/MOR/Agfa-NV/BE/BAYER@AGFA, "Sandro Hawke <sandro"            
            >              cc:       ext Graham Klyne <>, <>,                 
                      2003-11-11 12:20         Subject:  Re: What is the most common type of collection or container?                  

On 2003-11-11 01:51, "ext Jos De_Roo" <> wrote:

> That's a very good point; we tested that given
> :L rdf:first :a; rdf:rest :B. :B rdf:first :b; rdf:rest rdf:nil.
> :M rdf:first :c; rdf:rest :C. :C rdf:first :d; rdf:rest rdf:nil.
> :a owl:sameAs :c.
> :b owl:sameAs :d.
> we could OWL Full entail
> :L owl:sameAs :M.
> (and it was the case)

Well, that's all fine and dandy (though I'm left wondering what
justifies the test cases, since nothing is said in the normative
specs about the owl:FunctionalProperty nature of rdf:first and
rdf:rest (if it's there, I couldn't find it...)

Still, though, I think this still misses my key point. Even if
OWL enables you to detect a contradiction, you can only resolve
it by differentiating between statements based on their source
(authority/trustworthiness being inferrable from the source).

I.e. if

:L rdf:first :a .
:L rdf:rest :B .
:B rdf:first :b .
:B rdf:rest rdf:nil .

syndicated with

:B rdf:rest :C .
:C rdf:first :c .
:C rdf:rest rdf:nil .


:C owl:sameAs rdf:nil .

(and it should, if rdf:rest is in fact an owl:FunctionalProperty)

Then your OWL application is faced with a contradiction. Even if
rdf:rest is not an owl:FunctionalProperty, you're still left with
a dilemma.

Only one of the assertions

:B rdf:rest rdf:nil .
:B rdf:rest :C .

can be correct. But exactly how does one know which is correct,
whether the list ends at :B or continues on to :C?

OWL might allow you to catch munged lists, but it doesn't enable
you to resolve them, or to simply avoid them by filtering assertions
by source/authority/trustworthiness.

Tracking the source of such assertions is necessary to either
resolve the contradiction or avoid it altogether -- yet if you
have the machinery for tracking the source of assertions, you
don't need the RDF list machinery to define collections, since
you can just use rdf:member or any similar property and limit
ones focus (as needed/desired) to particular sources. I.e.

:src1 :L rdf:member :a .
:src1 :L rdf:member :b .
:src2 :L rdf:member :c .
:src3 :src1 rdf:type :TrustedSource .

SELECT ?member
WHERE  {?src :L rdf:member ?member}
AND    {?x ?src rdf:type :TrustedSource};

or even

SELECT ?member
WHERE  {?src :L rdf:member ?member}
AND    {?src = :src1};

No special list constructs, nor special APIs to manipulate them
are needed. And one can be *sure* of the completeness and validity
of the collection insofar as the trusted and/or explicitly specified
sources are concerned.


Received on Tuesday, 11 November 2003 07:46:05 UTC