TEST: sameGuy: it works with TRIPLE

```Hi,

triple.semanticweb.org)
on the sameGuy problem. Attached is the complete TRIPLE file and the RDF file
for the ones who want to try it yourself.
The example is called with:
triple -rdfdata sameGuy.rdf "http://www.w3.org/2002/03owlt/" sameGuy
sameGuy.triple

We didn't use a description logics reasoner.

Here is how it works:
We axiomatized the semantics of equality and sameIndividualAs as  follows:

//namespace declarations
contact:="http://www.w3.org/2000/10/swap/pim/contact#".
ont:="http://www.w3.org/2001/10/daml+oil#".
rdf:="http://www.w3.org/1999/02/22-rdf-syntax-ns#".
examples:="http://www.w3.org/2002/03owlt/".

// we define a new intensional model with a parameter Mdl (another RDF model)
FORALL Mdl @unambig(Mdl) {

FORALL O,P,V O[P->V] <- O[P->V]@Mdl .
// everything that is true in model Mdl is also true in unambig(Mdl).

FORALL O1,O2,P,V
O1[ont:sameIndividualAs->O2] <-
P[rdf:type->ont:UnambiguousProperty] and
O1[P->V] and O2[P->V] .
// define the semantics of ont:sameIndividualAs: O1 is the
sameIndividualAs O2
// if there is an UnambiguousProperty P and O1 and O2 have for P the same
value

// sameIndividualAs is an equivalence relation - we need to axiomatise it
FORALL X,Y X[ont:sameIndividualAs->X].
//reflexivity

FORALL X,Y X[ont:sameIndividualAs->X]<-Y[ont:sameIndividualAs->X].
//symmetry

FORALL X,Y,Z
X[ont:sameIndividualAs->Z] <-
X[ont:sameIndividualAs->Y] and Y[ont:sameIndividualAs->Z].
//transitivity
}

then the query:

FORALL O,V <-
O[ont:sameIndividualAs -> V]@unambig(examples:sameGuy). //passes the
RDF model examples:sameGuy as a parameter

asking for all sameIndividualAs in the example RDF file with the
semantics of UnambiguousProperty and equivalence applied returns:

O = _h34812, V = _h34812
O = 'urn:rdf:':c725a59a6b34c603df7491e1d7209a11, V
='urn:rdf:':c725a59a6b34c603df7491e1d7209a11
O = 'urn:rdf:':c725a59a6b34c603df7491e1d7209a11, V =
'urn:rdf:':aa0a6081f7e30ebd06c1f5d40264334e
O = 'urn:rdf:':aa0a6081f7e30ebd06c1f5d40264334e, V =
'urn:rdf:':c725a59a6b34c603df7491e1d7209a11
O = 'urn:rdf:':aa0a6081f7e30ebd06c1f5d40264334e, V =
'urn:rdf:':aa0a6081f7e30ebd06c1f5d40264334e

equivalent to itself - this
follows from reflexivity.
The other answers contain the internal IDs given from Jena to the anonymous
resources and
refer the equivalence relationships.

If we want to return all properties for the individuals we need to
introduce another model, which
takes sameIndividualAs into account for query answering:

FORALL rdfmodel @sameIndividual(rdfmodel){
FORALL O,O1,P,V,V1
O[P->V] <-
O[ont:sameIndividualAs->O1]@unambig(rdfmodel) and
V[ont:sameIndividualAs->V1]@unambig(rdfmodel) and
O1[P->V1]@rdfmodel.
// take for query answering the sameIndividualAs property into account
}

The query:
FORALL O,X,P,V <-
O[P->V]@sameIndividual(examples:sameGuy).

returns all triples that follow from the sameIndividualAs semantics.
The RDF file that we obtain if we dump
the  sameIndividual(examples:sameGuy) model
contains the triples in Dan's conclusion  (modulo renaming of anonymous
resources).

All the best,

Stefan

At 11:39 AM 3/7/2002, Dan Connolly wrote:
>In our telcon today, I took an action
>to provide a handful of tests, and
>other folks took actions to try the
>tests with their implementations (FaCT,
>Euler, a prolog thingy, TRIPLE, Jena? ...)
>and report back.
>
>Ian, where are those FaCT/shiq tests?
>I'll see if I can convert them to DAML+OIL.
>
>Meanwhile, this sameGuy test is available
>in two forms: in premise/conclusion form, we have:
>
>   http://www.w3.org/2002/03owlt/sameGuyP.rdf
>   v 1.2 2002/03/07 19:20:08
>and
>   http://www.w3.org/2002/03owlt/sameGuyC.rdf
>   v 1.2 2002/03/07 19:19:22
>
>follows from sameGuyP and let us know the results.
>
>Or...
>
>In consitency-check form, we have
>the whole question in one file:
>
>   http://www.w3.org/2002/03owlt/sameGuyQ.rdf
>   v 1.1 2002/03/07 19:20:08
>
>tell me if it finds an inconsistency.
>(It should.)
>
>It occurs to me that not only is
>the single-file consistency check
>less of a tutorial/example, it also
>exposes different forms of incompleteness.
>For a complete reasoner, the two tests
>look pretty much the same. But for
>an incomplete reasoner, perhaps not.
>
>My reasoner is incomplete. I had to tell
>it a whole bunch more about DAML+OIL to
>give me the relevant result about sameGuyQ
>than I did for sameGuyP/sameGuyC.
>
>Please let us know of any issues that arise
>when you try to run this test with your software.
>
>For example, in IRC, libby asked whether
>query systems fit in somehow. I think that's
>a good question. I'm interested in thoughts
>on how to run this test in a query system.
>
>
>--
>Dan Connolly, W3C http://www.w3.org/People/Connolly/
```

Received on Monday, 11 March 2002 12:50:57 UTC