Dear DAML researchers!
Currently I am reading into concepts and architectures related to semantic
web, and DAML looks very promising to me.
However, I feel that I came accross some problems with the interrelation of
DAML and RDFS. A first (possibly wrong!) result of my research is, that a
simplified but syntax of DAML is possible. I would like to claim that
simplification can be achived by cutting the dependencies with RDFS.
However, this might be a great misconception of mine. Therefore I am
seeking for information which important point of the RDFS/DAML concept I
might have missed respective which wrong assumptions or conclusions I made.
This e-mail is an attemt to gather feedback about my view of DAML and its
relation to RDFS, and maybe to get some explanation or information I am not
aware of yet.
Contents of this e-mail:
------------------------
In the first part of this e-mail I want to enumerate some of the reasons
which seem to motivate and justify a simplified syntax. In the second part
of this e-mail I briefly describe how a simplified syntax could look like.
PART I: Reasons why RDFS can be dropped from DAML
--------------------------------------------------
1) DAML already overtook the core job of RDF (and RDFS)
First I need to make clear what I view as the essential job (main benefit)
of RDF:
A good description of the essential benefit of RDF can be found in [1],
which describes that a statement can be written down in XML in _many_ ways,
but in RDF only in _one_ way. (quote [1]: "The same RDF tree results from
many XML trees".)
If i understand it correctly, this is achieved because RDF allows me to
express "a property of type P with a value of V is assigned to ressource
R", and the really good thing of this is that P (and V) can be explicitly
defined in an RDF-Schema. Therefore, if a reader knows the definition of P
she/he knows the intended meaning of the statement.
Okay, given that this is the main benefit of RDF, why do I claim that DAML
has already overtaken it?
I would say simply because the DAML+OIL language specification [2] copies
the mechanism to introduce properties from RDFS! People defining DAML
schemas are now writing <daml:Property> instead of <rdfs:Property>. This
makes me feel that the Property-construct is now a part of DAML rather than
only part of RDFS.
DAML not only overtook this mechanism, it also extended it:
ObjectProperties can be distinguished from DatatypeProperties, etc.
What DAML does is exactly what Bernes-Lee claims for RDF: it allows to
define meaning for constructs of new languages, in order to reduce the
difference between the "logical tree" of a document and its possible XML
based serializations. And it does so by using _its own_ constructs (derived
from multiple sources, including RDFS)
2) Partially, DAML already dropped RDF(S)
In [3], Rafel-Schneider and van Harmelen provide a list of language
concepts that where _not_ included into the DAML specification. Among these
concepts are
- reification of statements
- containers
- meta classes. The problem of meta classes was also tracked down by Pan
and Horrocks in [4]. Among the negative consequences of meta classes is
that RDF and RDFS are error-prone due to what is called the "layer mistake"
[4].
3) So, does DAML+OIL build on top of RDFS or not?
There are some presentation slides going around (e.g. [5]), depicting the
"Ontology Language Stack", which answer the question with a clear "yes":
L6 DAML-S (DAML-R, DAML-L)
L5 DAML+OIL
L4 RDFS
L3 RDF
L2 XML, Namespaces, URIs
L1 Unicode
But I think this expresses rather a wish than the reality. In particular, I
have two problems with this harmonic picture:
i.) I believe the DAML+OIL and RDFS layer are not that well seperated as
these presentations might suggest (e.g. associations with the ISO-OSI
network reference layer) Some reasons why there exists no such clean
separation where provided in chapter 1 and 2 of this e-mail. In other
words, RDFS and DAML+OIL are not complementary; in fact, they are
competing alternatives with lots of overlaps.
ii.) This layered model suggests (at least to me) that RDFS "assists" a
DAML programmer. It suggests that building on top of RDFS is the only way
to go. But as I understand it, it does not "assist" DAML+OIL programmers at
all: The DAML specification is written in RDFS, but its semantic/pragmatic
implications are still described in prosa!
This implies that an RDF aware application is not automatically aware of
DAML. What one needs to do in order to write a DAML parser is to filter all
the triples that contain DAML-elements or references to DAML-elements and
to construct a DAML object structure which represents _DAML_ constructs
(not RDF triples!). So I ask: why not parsing the objects directly (as it
is done with all other XML languages)?
This may leed to the following point:
What about reasoning?
-----------------------
If one wants to perform reasoning about a DAML ontology, she/he has two
possibilites:
- procedural approach: coding traversal routines etc. on top of the _DAML_
object structure, not on the triple-store. (i.e. the prosaic explanation of
DAML concepts is represented by hard coded inference algorithms)
- logical approach: converting all DAML construct to first order predicate
calculus, (i.e. the prosaic explanation of DAML concepts is represented by
axioms, as provided by Fikes and McGuinness in [6]) The RDF-triples could
be generated ex post, if they should be really necessary for reasoning with
FOL, couldn't they?
==> In essence, I think that in reality DAML does not really build on top
of RDFS, at least not in such direct way as often described.
If this conclusion of mine is correct, then there would be space for new
possibilities, new space for the much demanded "simplified" syntax of DAML,
wouldn't it?
PART II: A simplified syntax
--------------------------------------------------
If my interpretation (that DAML is based on a set of axioms, basically
independent from RDF) is correct, lots of simplification could be
introduced into DAML. In this e-mail I want to present a first thought,
mainly for discussion purposes.
The following example (from http://www.daml.org/2001/03/daml+oil-ex.daml)
shows a DAML-Class definition using RDFS:
<daml:Class rdf:ID="Animal">
<rdfs:label>Animal</rdfs:label>
<rdfs:comment>
This class of animals is illustrative of a number of ontological
idioms.
</rdfs:comment>
</daml:Class>
<daml:Class rdf:ID="Male">
<rdfs:subClassOf rdf:resource="#Animal"/>
</daml:Class>
<daml:Class rdf:ID="Female">
<rdfs:subClassOf rdf:resource="#Animal"/>
<daml:disjointWith rdf:resource="#Male"/>
</daml:Class>
This looks rather complicated, and again, I can not see the reason for this
RDFS-based notation; if my conclusions from part I of this e-mail are
correct (i.e. it is possible to drop RDFS from the syntax of DAML), then
one could write down the same information using the following simplified
syntax:
<Class ID="Animal">
<label>Animal</label>
<comment>
This class of animals is illustrative of a number of ontological
idioms.
</comment>
</Class>
<Class ID="Male">
<subClassOf resource="#Animal"/>
</Class>
<Class ID="Female">
<subClassOf resource="#Animal"/>
<disjointWith resource="#Male"/>
</Class>
A benefit of this simplified syntax would be 1) that more people would be
able to write ontologies and 2) that parsing DAML constructs would be a
very trivial process
my QUESTIONS to the community:
------------------------------
is my interpreation of the relation between DAML and RDFS correct? Is my
proposal (to write DAML in simplified notation and eventually convert it to
RDF ex post) a way to go?
I am totally aware that I am a novice in this research field and that I
entirely depend on the information that experts can provide to me.
Therefore I wrote to this list and i would be more than happy to get
feedback about the points I made in this e-mail.
thanks in advance!
Joachim
REFERENCES:
--------------
[1] Bernes-Lee, T.: "Why RDF model is different from the XML model", Draft
of a Design Note, 1998
http://www.w3.org/DesignIssues/RDF-XML.html
(sorry for citing a document draft which the author has not released, but I
think these informal design notes contain essential information)
[2] DAML+OIL language specification
http://www.daml.org/2001/03/daml+oil.daml
[3] Patel-Schneider, P, van Harmelen, F.: "Coordination points between
RDF(S) and DAML+OIL", 2001
http://www.daml.org/2001/07/RDFS-DAML+OIL-coordination.html
[4] Pan, J.Z.; Horrocks, I: "Metamodelling Architecture of Web Ontology
Languages", 2001
http://img.cs.man.ac.uk/jpan/Zhilin/download/Paper/Pan-Horrocks-rdfsfa-2001.pdf
[5] Goble, C "Grid, Ontologies and the Semantic Web" - Powerpoint
presentation, 2000
http://www.google.ch/search?q=%22the+ontology+language+stack%22&hl=de&meta=
[6] Fikes, R; McGuinness, D: "An Axiomatic Semantics for RDF, RDF-S, and
DAML+OIL", 2001
http://www.daml.org/2001/03/axiomatic-semantics.html