One issue and a brief Re on "A Logical Interpretation of RDF"

Thanks. That was very interesting. We departed by suggesting some
formalisable semantics for RDF SCHEMA (to make it more easily useable
for exchangability and extensibility) and the discussion immediately
moved towards "preciseness" of RDF M&S specs. So, I have to admit, that
starting with an "agreed upon" triple model (assuming its equivalence
to the other models) and determining what can be said about its relation
to SCHEMA concept semantics, was a little bit "blue-eyed".

This email has three brief parts. An [Issues] part mentioning one of the
topics that arose in the recent discussion, a [RDF without SCHEMA] part
that is a (personal) comment on RDF applicability (including two more
personal issues), and a [Answers] part with a brief remarks on one of
Brian's last emails.

Thanks for giving feedback,

(I hope that Reinhold shares my opinions, he'll be back from the EC-Web
tomorrow, so we'll see ;)


[Equivalence]: There are four RDF model "flavours" (formal/data model,
graph(ical) model, serialization syntax, triple). To what extend
(precisely) are these models (not) equivalent?  (Problems related to
anonymity have been discussed, see also below, details need to be
summarized). Could trying to find transformation grammars be a
solution (preciseness, determination of equivalence)? Shouldn't this be
in a "formal" part of M&S spec?


[RDF without SCHEMA]

Before saying a bit about my motivation to formalize RDF SCHEMA
concepts, allow two more personal "issues" that are related to the
recent discussion and may be not of general interest:

[Anonymity in triples]: The formal model states that "There is a set of
resources" etc. Too be complete, the model should also give an alphabet
allowing to "identify/create/represent" set members. This would
immediately show that there are no "anonymous" resources in the formal
model (because any r in the triple definition needs to be something
(that is: a piece of text in any "written down" instance of the set
theoretic model). What can be introcuded easily, however, would be a
NAME (as a property) for a resource (in addition to an identifier, which
might be explicit or may follow from document structure). Then, an
"anonymous" resource is simply a resource without
a name.

[RDF API - logic based]: From an RDF API, I would expect a very simple
set of possibilities: give me access to an inference engine where I can
feed triples in and make queries about (at least) a reasonable set of
predicates related to RDF schema
constructs (maybe the rules of our paper). Other APIs: what, exactly, do
you want to do with your RDF model? Is there anything that can't be done
more elegantly in logic? [This neglects the facts that a flat triple can
not contain anonyous resources, s. above.]

Now, "RDF without Schema" really starts:

The wish (or necessity) to have a "Logical Interpretation" arose during
Reinhold's effort to apply RDF to Web Engineering. He used RDF schema
constructs to define his XWMF model and he observed the necessity to
clearly state "which concept means what" to be able to
apply the concepts precisely and to define new constructs upon this

As you can see in the paper, we (maybe naively) departed from the formal
RDF model (Section5, M&S), also called "the RDF data model". In my
initial understanding, the formal model can be immediately expressed
with the triple model. So, our assumption was: Fine, we have some
flavour of RDF model (graphic/API, Serialization syntax, triples,
set theoretic) somewhere which can be transformed "lossless" into a set
of triples, so we can (simply) start with the assumption that a
"tripleization" is available.

With this codification of a model available, the stuff interesting for
applying RDF SCHEMA can be done: validation of models against the schema
semantics, querying the "schematic intentions" of the model (which
properties are allowed for a resource x?, to what classes does x
belong?) -- that is: the (schema) relationships among the concepts
of the model become transparent. And, IMHO, this is what's needed, if
RDF-SCHEMA-based models are exchanged -- a precise definition of the
schema concept semantics (you can still interpret the
subject-predictae-object "relations" as you like). If this is not
available, I can see no point in using RDF SCHEMA concepts for modelling
(if the interpretation of the concepts is left to the respective client
receiving it (ah, that is your notion of subclassOf, well, that's
interesting), a simple XML-vocabulary would do to
syntactically define the constructs). 

And what's left, if the SCHEMA concepts would not be used? Essentially,
the notion that "things" (resources/literals) can be related to each
other in a 2-ary, "named" relation (so, it becomes a triple) plus a few
special "keywords" (subject, predicate, object,
statement, bag, alt, seq, _1, ...) that denote some specific intentions
which are not always completely integrated into the underlying
set/relation theoretic model (details upon request).  Couldn't this also
be expressed in a minimal XML vocabulary with
<statements>,<subjects>,<predicates>,<objects> (adding the possibility
to name statements would even reender reification unnecessary, because
the precise interpretation/semantics of having a reifying resource and
DOING/USING is not given in the model, so giving a statement a name
(=promoting it to a resource, which it is anyway, because a statement is
given AS TEXT in an XML statement and is thus a PHYSICAL RESOURCE by
existence) and using this name in other statements can be interpreted as
a reification without any problem (only thing: it't a nested triple now
[x, represents, [s,p,o]]).

So, if you share my point of view that precise semantics for RDF SCHEMA
is important to ensure exchangability/applicability of RDF, you may want
to have a look into our paper and say, if you think that the simple
rules given there capture the intended semantics of (some of) RDF
SCHEMA. I, on the other hand, do agree with Stefan that being also
as precise as possible in regards to the issue of equivalence raised
above would be a good idea.


Much interesting (interesting for me, hopefully also for some others)
has been said, here is only a brief answer to one of the topics Brian

:How about, if x is the subject of a statement, its a resource,
:and if its the object of a statement, and not a literal, then its
:a resource.  

Oh, yes. That is exactly what the rules in the paper say. With the
additional "assumption" that anything "named" has an URI (see the first
"personal" issues about the "impossibility" of anonymous resources in
the triple model). By the way: this assumption is pretty nicely backed
by the M&S spec (2.1): "Resources are always named by
URIs plus optional anchor ids (see [URI])."

uri(S) & uri(P) & obj(O) <- s(S,P,O).
res(R) <- uri(R).
lit(O) <- obj(O) & -uri(O).

:That would deal with anon resources as well.

Well, not really. Because it (the resource) needs to be something (a
string) to exist (in a "textual" triple model, not in the "modelled"
world), so the
interpretation "it is named" applies.   (With respect to anonymous
resources, the flat triple model and, as a consequence, our "logical
interpretaion" are incomplete (or would require a convention such as
"reserved" names (ideally URI-confrom) for anonymous resources).

Thanks again,

Received on Wednesday, 6 September 2000 11:39:28 UTC