W3C home > Mailing lists > Public > www-webont-wg@w3.org > March 2002

LANG: A proposal for the layering problem

From: Jeff Heflin <heflin@cse.lehigh.edu>
Date: Fri, 22 Mar 2002 15:54:36 -0500
Message-ID: <3C9B9A0C.460F4FDA@cse.lehigh.edu>
To: WebOnt <www-webont-wg@w3.org>
It seems that most of the discussion on layering in this working group
has been leaning towards the unasserted triples idea. I don't believe
this is a very good solution. It seems extremely awkard and will make
the language extremely confusing for newbies. As a result, I've been
considering alternatives, and have developed the following proposal. In
terms of Peter and Dieter's "Layering" document, this proposal is
probably best described as a diverging sytax and diverging semantics
proposal (although it might be a syntactic and semantic extension of

This is a rather long message, so let me summarize the proposal here. I
propose that OWL's syntax has the following properties:
1) OWL syntax is a subset of XML syntax, i.e., every OWL file is an XML
2) OWL syntax is a superset of RDF syntax, i.e., every RDF file is an
OWL file
3) OWL syntax may be slightly or totally different from that of RDF
4) There will be some statements in the OWL syntax that do not assert

With this approach all existing RDF files may still be used as data in
OWL. However, OWL will be an ontological alternative to RDFS. In
particular we can choose not to have to write our ontologies in RDF.
Note that the RDFM&S Section 1 says that "Schemas MAY themselve be
written in RDF." There is no requirement placed on us to write schemas
(or ontologies) in RDF. If writing schemas in RDF is problematic, then
we should seriously consider alternative syntaxes.

There are number of potential problems with the RDFS approach of
designing a language. I will enumerate some of them here.

1) In order to represent closed lists in DAML+OIL, we had to resort to
the odd 'parseType="daml:collection"' mechanism. This was syntactic
sugar for the awkward cons-pair first-rest form of building lists.
Although LISP fans may be quite comfortable with this, the rest of the
world finds it very unintuitive.

2) People who try to add logical operators to RDF find themselves
unintentionally asserting all of the components of their complex
sentences. As a result, people have to resort to reification or
"unasserted triples" to express something that is really quite simple to
say in logic.

3) The Peter Patel-Schneider paradox. Although I admit I don't
completely understand it, it troubles me. Unless somebody can prove him
wrong, we have to take it seriously.

Someone may argue that this proposal will result in an incombatibility
with deployed RDF applications, but there don't appear to be a wide
number of RDF Schemas in use. Anyway, it should be rather trivial to
convert any RDF Schema to whatever new syntax we decide on. Some tool
builders may find that their RDFS tools don't work with OWL, which is
unfortunate, but I don't think that should be the sole reason for
sticking with an ungainly approach. Also note that in my proposal,
existing RDF data IS still compatible with OWL, and can be used with no
changes whatsover. 

What might such a language look like? Rather than provide a complete
syntax, I'll suggest some examples. If enough people think this is a
promising direction, I will put together a more complete proposal. Note
I began working on these ideas before I saw the van Harmelen et al.
proposal, so the names of language constructs are pretty different.
However, I don't think the semantics are all that different, so I think
it would be relatively simple to combine ideas from their proposal and
this one. The main difference is that their proposal focused on what
constructs the language should have, while this one focuses on XML


  <!-- The following say a Human is a Man or a Woman -->
  <owl:class ID="Human">
        <owl:class ref="#Man" />
        <owl:class ref="#Woman" />

  <!-- The following says a Faculty (member) is both a researcher and a
       teacher.  -->
  <owl:class ID="Faculty">
        <owl:class ref="#Researcher" />
        <owl:class ref="#Teacher" />

  <!-- This says that a trio has three members, all of whom are
musicians. -->
  <owl:class ID="Trio">
     <owl:hasProperty ref="#hasMember">
        <owl:cardinality value="3" />
	   <owl:class ref="#Musician" />

  <!-- The following says that a power trio has three members, including
       one guitarist, one bassist and one drummer. -->
  <owl:class ID="PowerTrio">
     <owl:hasProperty ref="#hasMember">
        <owl:cardinality value="3" />
        <owl:someValues cardinality="1">
            <owl:class ref="#Guitarist" />
        <owl:someValues cardinality="1">
            <owl:class ref="#Bassist" />
        <owl:someValues cardinality="1">
            <owl:class ref="#Drummer" />

  <!-- The following example has a specific value -->
  <owl:class ID="Person">
     <owl:hasProperty ref="#numEyes">
         <owl:someValues cardinality="1">


Note that instance documents would still be written in RDF. We could
even theoretically still use namespaces to identify which OWL ontology
the vocabulary came from.

Received on Friday, 22 March 2002 15:54:39 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:57:48 GMT