Re: tracing statement origin (was Re: I have a trouble with The RDF Model)

Gabe Beged-Dov <begeddov@jfinity.com> writes:

> Jonas Liljegren wrote:
>  
> > But we can't use the outmost Description bag as the model. 
> 
> What do you mean by the outmost Description bag?

There is no outmost Description bag.  That's why we can't use it as
the model. :-)


> My understanding is that reification of rdf:Descriptions will occur
> to all syntactic instances irrespective of whether they are
> top-level in the syntax or nested. 

My first reaction was that we maby could use the bagID as the model
id.  But we can't do that.


> Below is an explicitly labelled example and the resulting statements
> that are obtained by applying the StatementBag and Statement
> reification algorithm. I've included a typedNode shorthand on the
> first top-level resource for variety.

Great!  It's nice to see some examples.


> > The uri of the model will be the uri of the document.  It will
> > have metadata stating things about it's encoding, namespaces used,
> > time of retrieval, authority, and more.
> 
> I've been thinking about this a little. I'm wondering whether we might
> want another level of indirection between the base URI of the document
> and the resource from which we hang both  metadata (like that which
> you've described) and the document contents themselves. This
> indirection allows multiple versions of the document to exist and
> indicate that we have a representation of the source document that is
> based on a particular access pattern (kind of like the info that an
> HTTP proxy maintains). 

It's possible to have several readings of the same document by placing
the metadata itself in diffrent models (or bags).

New version of schemas should have new URIs.  We can still save older
versions of schemas that changes without changing the URI.  But we
need a standard way to represent models and I think that the base URI
can be simple enough.

Your example:

> http://somedoc.rdf:
> 
> <typedNode rdf:ID="res1" rdf:bagID="stat_bag1">
>   <prop1 rdf:ID="stat1">
>     <rdf:Description rdf:ID="res2" rdf:bagID="stat_bag2">
>        <prop2 rdf:ID="stat2">a value</prop2>
>     </rdf:Description>
>   </prop1>
> </typedNode>
> 
> <rdf:Description rdf:ID="res3">
>   <prop2 rdf:ID="stat3">another value</prop3>
> </rdf:Description>

Here is an example of how I was thinking of storing a model (using
'doc:' as namespace) (using [sta, sub, pred, obj]):

   [doc:stat1, doc:res1, prop1, doc:res2]
   [doc:genid1, doc:res1, rdf:type, typedNodeURI]
   [doc:stat2, doc:res2, prop2, "a value"]
   [doc:stat3, doc:res3, prop2, "another value"]
 
   [s1, http://somedoc.rdf, rdf:type, Model]
   [s2, http://somedoc.rdf, rdf:_1, doc:stat1]
   [s3, http://somedoc.rdf, rdf:_2, doc:genid1]
   [s4, http://somedoc.rdf, rdf:_3, doc:stat2]
   [s5, http://somedoc.rdf, rdf:_4, doc:stat3]

Model is subClassOf Collection (or Bag).  And to differentiate between
diffrent statings about the content of the model, we place the
metadata itself in a Selection:

  [s6, m1, rdf:type, Selection]
  [s7, m1, rdf:_1, s1]
  [s8, m1, rdf:_2, s2]
  [s9, m1, rdf:_3, s3]
  [s10, m1, rdf:_4, s4]
  [s11, m1, rdf:_5, s5]

And also s6-s11 will be placed in a model.  There is no end to it.
But in Wraf I implement it by storing a model for each stating and
lets a lot of things be implicit.


> Below is an attempt to capture this in rdf syntax for the example
> above. The statementBags property would chain the statement Bags to
> the Model instance. The Bags in turn chain the reified statement
> resources. We then have a complete tracing from a particular access to
> a source document down to the statements that occurred in that
> document. If we didn't have this complete tracing then we wouldn't be
> able to trace statements and statement bags contained in a document
> varying over time since the statements and statement bags have the
> document URI as thier identifer and different versions can't be
> distinguished without the chaining from the unique resource that
> represents the particular access to the document.

It will not help to just have diffrent resources for each access to
the document.  The statement IDs will be the same but the statement
will differ. Consider:

   [http://somedoc.rdf#stat1, rdf:type, rdf:Statement]
   [http://somedoc.rdf#stat1, rdf:subject, http://somedoc.rdf#res1]
   [http://somedoc.rdf#stat1, rdf:predicate, prop1]
   [http://somedoc.rdf#stat1, rdf:object, http://somedoc.rdf#res2]

   [http://somedoc.rdf#stat1, rdf:type, rdf:Statement]
   [http://somedoc.rdf#stat1, rdf:subject, http://somedoc.rdf#SomeThing]
   [http://somedoc.rdf#stat1, rdf:predicate, completely]
   [http://somedoc.rdf#stat1, rdf:object, http://somedoc.rdf#Diffrent]


My way of handling this is to put these statings in diffrent models.
But if the base URI is the same, and it's the base URI that is the
model, I can't do it.

I guess you're right.  We must have local control over the model URI.


> <ModelAccess>
>   <uri rdf:resource="http://somedoc.rdf">
>   <last_mod>timestamp</last_mode>
>   <last_access>timestamp</last_access>
>   <cache_until>timestamp</cache_until>
>   <authority>...</authority>
>   ...
>   <statementBags>
>     <rdf:Bag>
>       <rdf:li rdf:resource="http://somedoc.rdf#stat_bag1"/>
>       <rdf:li rdf:resource="http://somedoc.rdf#stat_bag2"/>
>       <rdf:li rdf:resource="http://somedoc.rdf#stat_bag3"/>
>    </rdf:Bag>
>   </statementBags>
> <ModelAccess>
>   
> ModelAccess is outside of anything that the M&S has touched on but I
> think it is very important for getting the next level of context
> needed for manipulating RDF on the web where context is everything.

Absolutly.  I take it you will write a proposal of a schema for
this. ;-)


But I wan't all the basic statements in the model.  Not just the
statementBags.  I could suffice with them.  But I would still generate
a complete list of statements in the model, because that's what I will
use in the application.  The uses of the statementBags are not as
many.

Maby we could have (support for) both:

> <ModelAccess>
>   <uri rdf:resource="http://somedoc.rdf">
>   <last_mod>timestamp</last_mode>
>   <last_access>timestamp</last_access>
>   <cache_until>timestamp</cache_until>
>   <authority>...</authority>
>   ...
>   <statementBags>
>     <rdf:Bag>
>       <rdf:li rdf:resource="http://somedoc.rdf#stat_bag1"/>
>       <rdf:li rdf:resource="http://somedoc.rdf#stat_bag2"/>
>       <rdf:li rdf:resource="http://somedoc.rdf#stat_bag3"/>
>    </rdf:Bag>
>   </statementBags>
    <statements>
      <rdf:Bag>
       <rdf:li rdf:resource="http://somedoc.rdf#stat1"/>
       <rdf:li rdf:resource="http://somedoc.rdf#genid1"/>
       <rdf:li rdf:resource="http://somedoc.rdf#stat2"/>
       <rdf:li rdf:resource="http://somedoc.rdf#stat3"/>
     </rdf:Bag>
   </statements>
> <ModelAccess>


But I would like to subclass Bag to give it more meaning.



-- 
/ Jonas Liljegren

The Wraf project http://www.uxn.nu/wraf/
Sponsored by http://www.rit.se/

Received on Tuesday, 28 November 2000 16:17:45 UTC