XML Reference Guide

Previously in our discussion, we defined the first version of the Blogging Ontology, naming the basic classes and their properties. To refresh your memory:

In this section, we'll look at the various pieces that are necessary to translate this information into Web Ontology Language, or OWL. (According to the W3C, the transposition is an obscure Winnie the Pooh reference.) We can then take that information and map the content of an actual blog into it.

The first thing you have to understand is that on the Semantic Web, OWL information is represented as RDF/XML information, but that doesn't mean that we're only dealing with rdf: elements. No, things are a bit more complicated than that. In general, you'll have four levels (or really, namespaces) in an OWL document:

• RDF: The Resource Definition framework was made for describing things in a standard way. It defines attributes such as ID and about and elements such as Description and Collection that can be used to describe various resources.
• RDF Schema: RDF is about as generic as you can get, but in creating descriptions, there are several terms, such as Class, subClassOf, and Property, that keep coming up over and over, and these are standardized within RDF Schema.
• OWL: The actual process of describing an ontology involves a number of standard elements and attributes, such as Ontology, imports, and DatatypeProperty.
• The instance document: In this level, everything gets put together to actually describe objects, or individuals. Typically this information lives in its own namespace.

Let's see how that all fits together by creating our ontology. We'll start with the overall structure:

<?xml version="1.0"?>

<!DOCTYPE owl [
   <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">
   <!ENTITY blogging "http://www.chaosmagnet.com/semanticweb/blogging#">
   <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
   <!ENTITY owl "http://www.w3.org/2002/07/owl#">
   <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
]>

<rdf:RDF
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:blogging="http://www.chaosmagnet.com/semanticweb/blogging#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xml:base="http://www.chaosmagnet.com/semanticweb/blogging"
    xmlns="http://www.chaosmagnet.com/semanticweb/blogging#">

<owl:Ontology rdf:about="http://www.chaosmagnet.com/semanticweb/ontologies">
   <rdfs:label xml:lang="en">Blogging Ontology</rdfs:label>
   <rdfs:label xml:lang="es">Blogging Ontology</rdfs:label>
   <rdfs:label xml:lang="de">Blogging Ontology</rdfs:label>

   <rdfs:comment>This ontology describes the objects and content of weblogs.</rdfs:comment>
   <owl:versionInfo>0.1</owl:versionInfo>
</owl:Ontology>

</rdf:RDF>

Starting at the top, we're defining a number of entities that we can use for namespace aliases within the actual data, and then we're defining the actual namespaces themselves. The blogging: namespace will be used to define the actual individuals, but for simplicity's sake I've also defined it as the default namespace.

Next we're defining the ontology itself. Notice that the Ontology element comes from the owl: namepsace, while the label and comment elements come from rdfs:. The best thing to do is not to obsess over where everything is coming from. Just be aware that there are several layers, and that you need to assign each element to the proper one. When you come right down to it, there aren't that many elements to remember, and it's easy to look them up.

In any case, we're describing the actual ontology. We can provide multiple values for the label and comment elements and distinguish them using the xml:lang attribute. (It just happens that the words "blogging ontology" are the same in most languages.) As for the versionInfo element, there's no set format for it. You can use a simple version, as I've done here, or the RCS/CVS keywords, or even a straight text description.

Now let's look at defining an actual class. We'll start with Blog:

...
   <rdfs:comment>This ontology describes the objects and content of weblogs.</rdfs:comment>
   <owl:versionInfo>0.1</owl:versionInfo>
</owl:Ontology>

<owl:Class rdf:ID="Blog">
  <rdfs:comment>This is the main class, from which Journal, LinkFest and 
                      TipSheet are derived.</rdfs:comment>

  <rdfs:label>Blog</rdfs:label>
</owl:Class>

</rdf:RDF>

Here we're defining a class named Blog and adding some context information for it. We can then add a property or two:

...
<owl:Class rdf:ID="Blog">
  <rdfs:comment>This is the main class, from which Journal, LinkFest and 
                      TipSheet are derived.</rdfs:comment>
  <rdfs:label>Blog</rdfs:label>
</owl:Class>

<owl:DatatypeProperty rdf:ID="isCalled">

  <rdfs:label>isCalled</rdfs:label>
  <rdfs:range rdf:resource="&#xsd;string"/>
  <rdfs:domain rdf:resource="#Blog" />
</owl:DatatypeProperty>

</rdf:RDF>

Here we're creating a property called isCalled. That property is a simple data type, and the kinds of data it can hold are defined by the range, in this case a string. The objects to which it can apply are defined by the domain, which in this case refers back to the Blog definition. (As in XML proper, the pound sign (#) refers back to an ID value.)

We can also create object properties, but before we do that, let's look at creating an instance, or "individual". We can do it in two different ways. The simplest is to use the name of the class:

<Blog rdf:ID="chaosmagnet">
   <isCalled>Chaos Magnet</isCalled>
</Blog

Notice that we can also specify the properties for the individual right there in the definition.

Now, I am going to try and keep this all as simple as possible, but let me digress for a moment and point out that OWL is, at heart, an application of RDF, so we could just as easily use RDF notations for defining our individual, as in:

<rdf:Description rdf:about="#chaosmagnet">

  <rdf:type>
    <owl:Class rdf:about="#Blog">
    </owl:Class>
  </rdf:type>
  <rdfs:label>Chaose Magnet</rdfs:label>

  <blogging:isCalled rdf:type="
s;string">Chaos Magnet</blogging:isCalled>
</rdf:Description>

I trust you won't mind if I stick to the simpler version.

OK, now that we've got the basics down, let's look at another kind of property: the ObjectProperty. Adding a string property was pretty straightforward, and actually adding another object as a property isn't that much more complicated:

...
  <rdfs:domain rdf:resource="#Blog" />

</owl:DatatypeProperty>

<owl:Class rdf:ID="Author">
  <rdfs:label>Author</rdfs:label>
</owl:Class>

<owl:DatatypeProperty rdf:ID="isNamed">
  <rdfs:label>isNamed</rdfs:label>

  <rdfs:range rdf:resource="&#xsd;string"/>
  <rdfs:domain rdf:resource="#Author" />
</owl:DatatypeProperty>>

<owl:ObjectProperty rdf:ID="hasAuthor">
  <rdfs:domain rdf:resource="#Blog" />
  <rdfs:range rdf:resource="#Author" />

  <rdfs:label>hasAuthor</rdfs:label>
</owl:ObjectProperty>

</rdf:RDF>

First I've defined another class, Author, which itself has a string property, isNamed. We can then use that class to define an ObjectProperty, hasAuthor. Using these structures in creating individuals is similar to the first example:

<Author rdf:ID="NicholasChase">
   <isNamed>Nicholas Chase</isNamed>
<Author>

<Blog rdf:ID="chaosmagnet">
   <isCalled>Chaos Magnet</isCalled>
   <hasAuthor rdf:resource="#NicholasChase">

</Blog>

Now, believe it or not, that's really the heart of creating content in Web Ontology language. You create the classes and properties, and then you instantiate individuals. That's it.

Of course, if that were all you could do with OWL, it wouldn't be all that useful. We talked previously about subclasses, transitive properties, and so on, so let's see how those fall out.

First, let's talk about subclasses. For example, we talked about three subclasses of the Blog class, so we can go ahead and define them:

...
<owl:Class rdf:ID="Blog">

  <rdfs:comment>This is the main class, from which Journal, LinkFest and 
                      TipSheet are derived.</rdfs:comment>
  <rdfs:label>Blog</rdfs:label>
</owl:Class>

<owl:Class rdf:ID="Journal">
  <rdfs:subClassOf rdf:resource="#Blog" />

  <rdfs:comment>A set of personal musings.</rdfs:comment>
  <rdfs:label>Journal</rdfs:label>
</owl:Class>
<owl:Class rdf:ID="LinkFest">
  <rdfs:subClassOf rdf:resource="#Blog" />

  <rdfs:comment>A collection of links to other resources.</rdfs:comment>
  <rdfs:label>LinkFest</rdfs:label>
</owl:Class>
<owl:Class rdf:ID="TipSheet">
  <rdfs:subClassOf rdf:resource="#Blog" />

  <rdfs:comment>A collection of handy tips or advice.</rdfs:comment>
  <rdfs:label>TipSheet</rdfs:label>
</owl:Class>

...

Note that OWL allows multiple-inheritance, so you can create a class that subclasses more than one class by simply adding more than one subClassOf element.

We can use these definitions just as we'd use any other class. For example, I could define Chaos Magnet as a TipSheet instead of as a straight Blog:

<TipSheet rdf:ID="chaosmagnet">
   <isCalled>Chaos Magnet</isCalled>
   <hasAuthor rdf:resource="#NicholasChase">

</TipSheet>

Because TipSheet is a subclass of Blog, it automatically gets the hasAuthor property. You can also add additional properties to a subclass. For example, the Review class is a subclass of Entry, so it gets all of Entry's properties, but you can also specifically define the isOf and givesRating properties and add them to the Review class.

We can also define properties of properties. In other words, there are ways in which properties can be used. For example, although it would take up way too much space to show the whole ontology here -- look for a link on the resources page -- we'll also have a hasContent property that applies to both a Blog and an Entry. Text that is part of the content of an Entry is also part of the content of the Blog containing that Entry. But that only happens if we declare the hasContent property to be transitive, like so:

<owl:ObjectProperty rdf:about="#hasContent">
  <rdf:type rdf:resource="&owl;TransitiveProperty" />
  <rdfs:domain>
    <owl:Class rdf:about="#Blog">
    </owl:Class>
  </rdfs:domain>

  <rdfs:domain>
    <owl:Class rdf:about="#Entry">
    </owl:Class>
  </rdfs:domain>
  <rdfs:label>hasContent</rdfs:label>

</owl:ObjectProperty>

Another type of properties is an inverse property. For example, if a blog has an author, we also know that that author writes that blog. We can create that relationship like this:

<owl:ObjectProperty rdf:ID="writes">
  <rdfs:domain rdf:resource="#Author" />
  <rdfs:range rdf:resource="#Blog" />
  <owl:inverseOf rdf:resource="#hasAuthor" />

  <rdfs:label>hasAuthor</rdfs:label>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="hasAuthor">
  <rdfs:domain rdf:resource="#Blog" />
  <rdfs:range rdf:resource="#Author" />
  <owl:inverseOf rdf:resource="#writes" />

  <rdfs:label>hasAuthor</rdfs:label>
</owl:ObjectProperty>

(Note that we don't actually have to define both properties as inverses. Just defining one implies the other.

We can also define properties that are "functional" and "inverse functional". A functional property is one for which there can be only one unique value. For example, we could say that each blog is uniquely described by its URL. (That may or may not be a good idea, but let's go with it for the moment.) If we did that, we have the following definition:

<owl:DatatypeProperty rdf:ID="hasURI">
  <rdfs:label>hasURI</rdfs:label>
  <rdf:type rdf:resource="&owl;FunctionalProperty" />
  <rdfs:domain rdf:ID="Blog" />
  <rdfs:range><rdfs:Datatype rdf:about="&#xsd;anyURI"/></rdfs:range>

</owl:DatatypeProperty>

Now, this means that the hasURI property acts as a sort of primary key for the Blog class. There's a one-to-one relationship between an individual and its hasURI value. That said, it means that if we have the URI, we know what individual it refers to. That's known as an inverse functional property:

<owl:DatatypeProperty rdf:ID="isURIFor">
  <rdfs:label>isURIFor</rdfs:label>
  <rdf:type rdf:resource="&owl;InverseFunctionalProperty" />
  <rdfs:range rdf:resource="&#xsd;anyURI" />
 <owl:inverseOf rdf:resource="#hasURI" />

</owl:DatatypeProperty>

There's a whole lot more to defining ontologies with OWL than I could ever show you in just one section of this guide, so please check out the resources for more information on the power of this language.