Scope/Context specific run-time selection of Assertions

On 2002-06-24 10:57, "Patrick Stickler" <patrick.stickler@nokia.com> wrote:


> OWL level assertions can be easily automated using this approach
> by a single rule:
> 
> {
>  ?x rdf:type rdf:Statement .
>  ?x rdf:subject ?s .
>  ?x rdf:predicate ?p .
>  ?x rdf:object ?o .
>  ?p rdf:type owl:OWLPredicate .
> }
> log:implies
> {
>  ?s ?p ?o .
> }
> 
> Done.

It just occurred to me that this would be a very powerful and
flexible approach to run-time selection of assertions based
on scope, authority, etc. where one simply defines the rules
which select and assert statements relevant to a given query
or inference operation.

Thus, all statements would be made in reified, unasserted form, and
the graph would, by default, contain few actual triples -- really
only those expressing the meta-structure of the statements
themselves and some core knowledge about RDF, RDFS, and
the particular ontologies employed.

E.g.

[ a rdf:Statement ;
   rdf:subject foo:name ;
   rdf:predicate rdfs:label ;
   rdf:object "Name" ;
   rdfx:scope [ xml:lang "en" ] ] .

[ a rdf:Statement ;
   rdf:subject foo:name ;
   rdf:predicate rdfs:label ;
   rdf:object "Nimi" ;
   rdfx:scope [ xml:lang "fi" ] ] .

And at run-time

{
  ?x rdf:type rdf:Statement .
  ?x rdf:subject ?s .
  ?x rdf:predicate ?p .
  ?x rdf:object ?o .
  ?x rdfx:scope [ xml:lang "fi" ] ] .
}
 log:implies
{
  ?s ?p ?o .
}

And then a query

  foo:name rdfs:label ?o

would only bind to the Finnish language value since
that is the only statement asserted at the time of
the query.

Or, another example

[ a rdf:Statement ;
   rdf:subject <#Bob> ;
   rdf:predicate rdf:type ;
   rdf:object foo:Idiot ;
   rdfx:authority <auth://abc.com/Mary> . ]

[ a rdf:Statement ;
   rdf:subject <#Bob> ;
   rdf:predicate rdf:type ;
   rdf:object foo:Genius ;
   rdfx:authority <auth://abc.com/Joe> . ]

and then locally

<auth://abc.com/Joe> a <#TrustedAuthority> .

{
  ?x rdf:type rdf:Statement .
  ?x rdf:subject ?s .
  ?x rdf:predicate ?p .
  ?x rdf:object ?o .
  ?x rdfx:authority [ rdf:type <#TrustedAuthority> ] .
}
 log:implies
{
  ?s ?p ?o .
}

Which only asserts statements from trusted authorities.

Etc.

This essentially treats assertions as a matter of
context, or perspective. I.e., each application, or
really, each individual query of a knowledge base
can specify for itself what should be considered
true, according to the context or perspective of
its operation.

I expect that this is nothing new, per se, but it
struck me as a very useful approach to defining a
web of trust as well as dealing with layers and
other subsets of interest.

I wouldn't be surprised if this was very similar to
how Topic Map queries are modelled with regard to
scope.

I would expect, though, that it could easily get very
inefficient if assertions are to be determined for
every query of the knowledge base. One would probably
constrain such statement selection on a per-session
basis, defining the criteria for selection when
initializing the session. Changes to those criteria
would constitute a new session.

Cheers,

Patrick

--
               
Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email: patrick.stickler@nokia.com

Received on Monday, 24 June 2002 04:50:36 UTC