TEST: sameGuy: it works with TRIPLE

Hi,

Michael and I are able to demonstrate TRIPLE (downloadable from 
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

The first answer is the "generic answer" that every individual is 
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
>
>Please ask your software to check that sameGuyC
>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
>
>Please feed that to your engine and
>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/