From: Stefan Decker (stefan@db.stanford.edu)
Date: 05/29/01
Hi Pat,
At 05:58 PM 5/29/2001 -0500, pat hayes wrote:
>>Hi,
>>
>>some additions to Pats suggestion:
>>
>>1) In many applications it is important to distinguish between different
>>kind of RDF data, eg.
>> between different sources of RDF data, one is trustworthy, the other one
>> not.
>
>That seems to me to be an assertion about the source rather than the data
>(?) But in any case it goes well beyond the RDF or DAML semantics.
If we built a rule language for processing of RDF data it is necessary to
distinguish
different sets of RDF data. One example where it is important to
distinguish between
different kind sets of RDF data is when it comes from different sources,
and that
it originates from different sources is a property of the data.
There are other applications areas, e.g. the computation of different
semantics (see my RDF Schema
example).
>>This needs to be reflected in the rule language - it is not sufficient to
>>just query if a certain
>> fact is present. To distinguish between different sources would be
>> enabled by model identifiers
>>
>>subject[predicate->object]@model
>
>I have no idea what you are talking about. What is a 'model' in this sense?
A set of RDF statements (triples).
>>It is also possible to allow operations on models, e.g. intersection,
>>union and setdifference.
>
>They sound like classes to me.
>
>>1) subject[predicate->object]@(mod1 intersect mod2)
>>2) subject[predicate->object]@(mod1 union mod2)
>>3) subject[predicate->object]@(mod1 \ mod2)
>>
>>1+2+3 are allowed in a rule body, only 1 is allowed in a conclusion
>>(this still allow to have a horn clause interpretation).
>>
>>Finally, for most applications it is also useful to allow skolem functions
>>as model identifiers, e.g.
>>
>>subject[predicate->object]@model(X)
>>
>>This allows parameterized models
>>
>>Furthermore: Full first order language bodies can be achieved by the
>>Lloyd-Topor Transformation,
>
>Can you give a pointer? I havnt heard of this.
Lloyd, J. W. and Topor, R. W., Making Prolog More Expressive, Journal of
Logic Programming 3:225--240 (1984).
also in J.W. Lloyd. Foundations of Logic Programming. Springer-Verlag, 2nd
edition, 1987.
The principle if very easy:
The existential quantifier, conjunction and negation is a basis
for FOL, thus one can allow FOL statements as bodies (which of course don't
have the same
semantics as FOL, but a semantics according to the negation semantics, e.g.
well founded semantics).
This trick helps to formulate a lot of rules very elegantly, and it is
_not_ limited to Prolog
(as the above title suggests)
>>provided
>>e.g. semantics for negation. Well-founded semantics is usually regarded
>>as the most suitable one -
>>especially in the case of RDF (just one predicate symbol).
>
>This idea of there being only one predicate symbol is a joke, right?
If we just allow triples as atoms, no. How do you encode rdf statements?
There are several possibilities:
1) triple(subject, predicate, object).
That does not take context (model identifier) into account.
Another possibility is
2) triple(subject, predicate,object, context).
And I prefer:
3) trueInContext(rdfstatement(Subject,Predicate,Object),context).
since this allows a very elegant representation of reification (or
whatever we name it).
(e.g.
trueInContext(rdfstatement(rdfstatement(S2,P2,O2),Predicate,Object),context).
represents a statement about a statement.
All the best,
Stefan
>Pat
>
>---------------------------------------------------------------------
>IHMC (850)434 8903 home
>40 South Alcaniz St. (850)202 4416 office
>Pensacola, FL 32501 (850)202 4440 fax
>phayes@ai.uwf.edu http://www.coginst.uwf.edu/~phayes
This archive was generated by hypermail 2.1.4 : 04/02/02 EST