W3C home > Mailing lists > Public > semantic-web@w3.org > April 2005

Re: RDF, RDFS, and OWL language constructs

From: Frank Manola <fmanola@acm.org>
Date: Mon, 25 Apr 2005 10:35:28 -0400
Message-ID: <426D0030.6090308@acm.org>
To: Hans Teijgeler <hans.teijgeler@quicknet.nl>
CC: semantic-web@w3.org, Christiansen Thore <tore.r.christiansen@dnv.com>, "Valen-Sendstad, Magne" <magne.valen-sendstad@dnv.com>, "Leal, David" <david@cedarlon.demon.co.uk>, "Paap, Onno" <onno.paap@ezzysurf.com>, Matthew West <matthew.west@shell.com>

Hi Hans--

Sorry for delay in responding;  some deadlines reared their ugly heads. 
  About your questions:

Hans Teijgeler wrote:
> Hi Frank!
> Thanks for the help!
> It seems to me that we have a divide between two Semantic Webs:
>     * RDF + RDFS + OWL Full (the cumulation I mentioned: "OWL Full
>       contains all the OWL language constructs and provides free,
>       unconstrained use of RDF constructs.")
>     * OWL DL and its subset OWL Lite
> There is a lot in OWL DL that I like, but using OWL DL means de facto 
> throwing away RDF-RDFS (right?), and that seems not so nice.

I understand the concern, but I don't think the situation is as stark as 
all that.  In the first place, I'd put RDF in a separate category from 
the other languages.  One reason is that all the languages are RDF. 
That is, both RDFS and the OWL dialects are all descriptions of 
resources (that happen to represent classes, properties, and so on) in 

Also, instances that correspond to the various schema/ontology languages 
are going to be described in RDF as well.  If you look at the instance 
examples in the OWL documents, for example, they look like plain RDF; 
it's just that the language that describes the classes and properties 
happens to be OWL, rather than RDFS.  I can imagine lots of situations 
in which RDF instance data (data that doesn't *define* classes and 
properties, but just references classes and properties defined in RDFS 
schemas) could be "repurposed" to be used with OWL definitions of those 
same classes and properties (this wouldn't be true for all RDF instance 
data though).

The reason I think lots of instance data could work this way is this: 
While RDF per se (and RDFS) has practically no "type checking", OWL DL 
does.  But lots of applications (and languages) are organized around 
many of the sorts of constraints that OWL DL imposes (e.g., OO 
programming languages and database systems).  For example, most 
languages insist, as does OWL DL, that classes and instances be 
carefully separated.  Similarly, most languages require separating 
properties that have literals as values from those that have object 
instances as values.  Lots of modeling disciplines involve these sorts 
of assumptions as well.  Hence, I think lots of data (and schemas) will 
wind up being organized with such constraints, even when they aren't 
explicitly OWL.

However, it's natural that as you go from a less restrictive language 
(RDF, RDFS) to a more restrictive language (OWL DL), especially if 
you're retrofitting (you have a lot of RDF data which was formerly 
defined according to RDFS and you're trying to redo the schema in OWL) 
you may run into some problems.

> It appears to me that this divide now forces us to make a very important 
> choice between the two, where I had expected a smooth upgrade path RDF > 
> RDFS > OWL Lite > OWL DL > OWL Full. Too logical (or naive), I presume.

The "upgrade path" you mention wasn't really intended to be an upgrade 
path in the sense you have in mind.  As I've noted, RDF itself has few 
if any rules.  OWL Lite and OWL DL impose some restrictions on how their 
ontologies are defined.  However, I expect that lots of specialized RDF 
data that people will construct will be that way too.  That is, for a 
given application it seems to me that those responsible will build 
schemas that may define not only restrictions such as those that occur 
in OWL DL, but may also include additional specialized schema vocabulary 
to define constraints not currently included even in any OWL vocabulary 
(some pre-OWL applications I'm aware of defined their own RDFS 
extensions, some of which now be replaced by OWL constraints).  They 
will construct RDF according to their specialized vocabulary, and expect 
RDF that they input and use to conform (and will presumably build 
parsers and validity checkers to insure conformance).  Merging that data 
with external data not necessarily constructed according to that 
vocabulary (assuming they have that requirement) will of course require 
them to weaken any requirements of strict conformance (or deal with it 
using more powerful reasoners).  That's not surprising.
> Is there any way, e.g. a header, to tell the software whether you work 
> in DL or in Full?

I don't know that there's a header.  There are validity checkers that 
will tell you which OWL dialect your stuff conforms to, e.g., 

> Is there anything written on a migration path between the two in either 
> direction?

There's some material in the OWL documents that talks about migration 
(mostly it says that if you're starting with RDFS, your most obvious 
migration path is to OWL Full.)  There is also material there that 
provides guidelines on using RDF so it will not violate the OWL DL limits.

However, there's clearly some more work to be done on this issue.  You 
might be interested in tracking some of the discussion on such issues at 
the ESW Wiki, e.g., http://esw.w3.org/topic/OwlAndRdf.


Received on Monday, 25 April 2005 14:25:50 UTC

This archive was generated by hypermail 2.4.0 : Tuesday, 5 July 2022 08:44:53 UTC