Other Free Encyclopedias » Online Encyclopedia » Encyclopedia - Featured Articles » Contributed Topics from P-T

Semantic Web - Introduction, Benefits and Detailed Example, OWL Syntax and Description of Selected Key Aspects1, Classes and Subclasses

myns “http rdfs class rdf

Schahram Dustdar
Technical University of Vienna, Austria

Ben Falchuk
Telcordia Technologies, NJ, USA

Definition: The Semantic Web, in particular the W3C Ontology Web Language (OWL) Recommendation, provides powerful new use-cases for information retrieval, searching, and manipulation.


For the most part, today’s World-Wide Web provides the mechanisms for interactions between human users, web servers, and the content stored on servers. The HTML standard, while nicely render-able on Web browsers, is concerned almost exclusively with content presentation (as opposed to the meaning). This leads to problems when trying to enable software agent-based interaction with the web server content because HTML may not be easily machine-processable due to under-specified information semantics. Why is agent-based interpretation of the Web important? Consider the following use-cases (some from W3C specifications) which, for various reasons, are difficult to achieve based solely on the first generation Web (see for more details):

  • Corporate Web-site management of disparate but related documents such as briefings, research, white papers, and processes
  • Automated agent-based search for information; two examples are consumer applications which search for specific travel information, and business agents which search for and automatically inter-work with Internet business partners

The Semantic Web is one solution arc to the above problems; Description Logics (DL) combined with description languages such as XML, is another. DL is a family of knowledge representation languages with a formal logic-based semantics and can be an underpinning of domain representation and exploitation.

The remainder of this chapter presents both a review and some current research streams in the area of Semantic Web and Semantic Web Services. The former is concerned mainly with the techniques involved in adding semantics to World-Wide Web content, whereas the latter is focused on adding semantics to the area of Web Services and in describing, finding, and binding to Web Services.

Semantic Web Benefits and Detailed Example

The Semantic Web, in particular the W3C Ontology Web Language (OWL) Recommendation, provides powerful new use-cases for information retrieval, searching, and manipulation. This section provides a high level overview of the arguments that support the above statement. We present a running example (incorporated a W3C example found at www.w3c.org) and describe some of the ways in which OWL facilitates the powerful new use-cases. Where possible, we point out the limitations of the technologies that OWL supersedes (such as HTML, and RDF).

Figure 1 (left) shows the Web Services ‘stack’, as presented by Tim Berners-Lee in 2003. In comparison to the “current Web” we note that today’s Web technology stack (mostly HTML) would mostly sit above XML and below RDF. Related specifications such as Java Server Pages (JSP) (together with Java Server Faces), and Java Script add a layer of sorts above HTML, but with nowhere near the semantic richness of RDF and OWL. Note that Web Services (see www.w3c.org/2002/ws) have a complex ‘stack’ of syntax protocols themselves. Figure 1 (right) shows a ‘join’ between 3 disparate ‘tables’.

One table stores regions and their traditional meals, another stores meals, courses and wines, while a third stores grapes and their characteristics. In a Relational Database scenario a single company might store all 3 tables using identical technology; a join between them would therefore be simple. On the Internet, we cannot count on information having the format or meaning that we assume. Therefore, an Internet analogy to the Database join would not be easily possible with the current Web. For example, if the three tables were now three Websites with HTML information, one might see an HTML table of meals:

<table border=“l” cellpadding=“0” cellspacing=“0”>
   <tr><td>France</td><td>Bordeaux</td><td>Steak Frites</td></tr>
   <tr><td>France</td><td>Normandy</td><td>Magret de Canard</td></tr>

While the above HTML will render appealingly in most Web browsers and create a meaningful table for human users, the information therein is not easily interpreted by a software agent wishing to ‘joins’ this table with other information. This is because the HTML mixes presentation with semantic tags, cannot not make it explicitly clear what the table semantics are, and does not differentiate instances from labels, from examples, and so on (e.g .all the things that are easy for human readers to do). The HTML <meta> tag can be used to document a limited, but insufficient, amount of page metadata.

The Web Ontology Language (OWL), a W3C Recommendation and a Semantic Web building block, supports the kind of machine interpretability described above. W3C’s OWL Lite, OWL DL, and OWL Full are the three increasingly powerful variants of the OWL specification. The language is built on formalisms that admit to Description Logic (DL) forms and therefore allows reasoning and inference. Reasoning is the act of making implicit knowledge explicit. For example, an OWL knowledge base containing descriptions of students and their parents could infer that two students exhibited the ‘brother’ relationship if there were both male and shared one or more parent. No explicit markup indicating the ‘brotherhood’ relationship need ever have been declared. A Reasoning Engine is computational machinery that uses facts found in the knowledge base and rules known a priori to determine Subsumption, Classification, Equivalence, and so on. F-OWL, FaCT, and Racer are examples of such engines. OWL Full is so expressive that there are no computational guarantees that inferences can be made effectively and it is unlikely that any such engine will be able to support all its features soon. However, OWL Lite and subsets of OWL DL can be supported.

OWL Syntax and Description of Selected Key Aspects1

Suppose, as in the full example found in , that one wishes to create an ontology describing the domain of ‘wines’ (e.g. wine characteristics, wineries, grapes, regions, etc.), or, for example, people, drivers, pets, and animals as in. HTML, XHTML, and XML Schema, while ubiquitous, are not appropriate syntaxes because their semantics are simply not rich enough (and, to be fair, not designed to support reasoning).

Classes and Subclasses

OWL classes are groups of individuals that belong together. For example, the set of all ‘wheeled vehicles’ or the set of all ‘wineries’. A class is a key building block in the ontology as it can be subclassed (creating specialization hierarchy), and properties can be defined upon it. Instances of classes (sometimes called individuals) can also be created. The following code shows creation of a simple OWL class called ‘vehicle’ and subclass called ‘bicycle’:

<owl:Class rdf:about=“http://myNS#vehicle”>
<owl:Class rdf:about=“http://myNS#bicycle”>
     <rdfs:subClassOf=<owl: Class

1 OWL code snippets are illustrative only. For detailed explanation of the syntax, please see

Class Intersection, Disjointedness and Individual Equivalency

Classes can be defined by logical intersections of other named classes. This is a powerful feature not found in other formats (esp HTML and XML Schema). An example below shows a class called ‘grownup’ whose members are those that exist as members of both ‘person’ and ‘adult’ (i.e. a grownup is any adult person):

<owl:Class rdf:about=“http://myNS#grownup”>
<owl:Class=<owl:intersectionOf rdf :parseType=“Collection”>
     <owl:Class rdf:about=“http://myNS#adult”/>
     <owl:Class rdf:about=“http://myNS#person”/>

It is often useful to model artifacts as disjoint. For example if we want our reasoner to ‘catch’ the inconsistency of an artifact marked as both ‘pasta’ and ‘fowl’, the model can explicitly capture this disjointedness as follows:

<owl:Class rdf:ID=“pasta”>
<owl:disjointWith rdf:resource=“#meat”/>
<owl:disjointWith rdf:resource=“#fowl”/>

It is also often useful to allow ontology makers naming flexibility, in particular to allow different names for the same individual. OWL allows such a mechanism – for example, the code below an ontology creator declares Mike’s favorite wine as the same individual as ‘Texas White’:

<Wine rdf:ID=“MikesFavoriteWine”=<owl:sameAs


Modeling OWL Classes is a key step in ontology creation, but without OWL Properties there is little that ties the classes together beyond subsumption. OWL Properties relate classes and individuals to other classes, and also to data values. Each Property has a domain (the individuals to which the property applies) and range (the values the property may have). Properties may also form a hierarchy. For example, the snippet below defines a Property called ‘has_pet’ which associates ‘person’s to ‘animal’ individuals. In addition, the Property is a type of another Property called ‘likes’, and therefore inherits its characteristics.

<owl:ObjectProperty rdf:about=“http://myNS#has_pet”>
     <rdfs:subPropertyOf rdf:resource=“http://myNS#likes” />
<rdfs:domain=<owl:Class rdf:about=“http:  //myNS#person”/=</rdfs:domain>
<rdfs:rangexowl:Class rdf:about=“http:   //myNS#animal”/=</rdfs:range>

OWL Properties can also be defined as inverse to each other. For example OWL can capture the notion, “if an animal is ‘eaten_by’ another, then a 2 nd Property ‘eats’ is the inverse of ‘eaten_by’ because for any animal X eaten by Y the relation Y eats X also holds”. OWL also supports the modeling of transitive properties.

<owl:ObjectProperty rdf:about=“http://myNS#eats“>
     <owl:inverseOf rdf:resource=“http://myNS#eaten_by” />
     <rdfs:domain=<owl:Class rdf:about=“http://myNS#animal“  /=</rdfs:domain>

It should be becoming clear now how reasoning engines, executing upon large KB’s in which inverse and transitive Properties are defined, can exploit the benefits of these rich semantic linkages. Finally, Individuals are instances of Classes and are identified uniquely by the namespace and an rdf:ID identifier. The following OWL denotes that ‘CentralCoastRegion’ is an individual of the Class ‘Region’.

<Region rdf:ID=“CentralCoastRegion” />

This section has outlined only a small subset of the OWL syntax and artifacts. Readers should see and other definitive sources for more details.

OWL Reasoning Examples

In several illustrative examples of inference upon an OWL Knowledge Base (ontology plus its defined individuals) are presented. In general, one can talk about several types of inference which are demonstrable in Description Logics-based systems , including those systems captured in OWL:

  • Consistency - determine if the model is consistent. For example, presents an OWL model containing the facts: (a) cows are vegetarian, (b) sheep are animals, and © a ‘mad cow’ is one that has eaten sheep brain. From these facts a computational reasoning engine can infer that ‘mad cows’ are inconsistent since any cow eating sheep violates (a). The following (incomplete, but informative) OWL snippets help illustrate some salient issues. Informally, note the description of mad_cow (line 1). Note that mad_cow is an intersection class (line 4) defined as any cow (line 5) that has a property ‘eats’ (line 6) such that the range of that property (i.e. what it eats) is a part_of a sheep (lines 11, 13) and that part is a ‘brain’ (line 16). Below note that the ‘sheep’ class is defined as subclass of ‘animal’ while ‘cow’ is a subclass of ‘vegetarian’.

  • Subsumption – infer knowledge structure, mostly hierarchy; the notion of one artifact being more general than another. For example, presents a model incorporating the notions (a) ‘drivers drive vehicles’, (b) ‘bus drivers drive buses’, and (b) a bus is a vehicle, and subsumption reasoning allows the inference that ‘bus drivers are drivers’ (since ‘vehicle’ is more general than ‘bus’).

  • Equivalence - determine if classes in the model denote the same set of instances

  • Instantiation - determine if an individual is an instance of a given Class. This is also known as ‘classification’ – that is, determine the instance of a given Class.

  • Retrieval - determine the set of individuals that instantiate a given Class

1  <owl:Class rdf:about=“http://myNS#mad_cow”>
2  <owl:equivalentClass>
3    <owl:Class>
4       <owl:intersectionOf rdf:parseType=“Collection”>
5         <owl:Class rdf:about=“http://myNS#cow” />
6            <owl: Restrictionxowl: onProperty
7                <owl:someValuesFrom>
8                  <owl:Class>
9                      <owl:intersectionOf rdf:parseType=“Collection”>
10                         <owl:Restriction>
11                             <owl:onProperty
   rdf:resource=”http://myNS#part_of“  />
12                             <owl: soineValuesFrom>
13                                 <owl:Class rdf:about=“http://myNS#sheep” />
14                             </owl:someValuesFrom>
15                         </owl:Restriction>
16                         <owl:Class rdf:about=“http://myNS#brain” />
17                      </owl:intersectionOf>
18                  </owl:Class >
19                </owl:someValuesFrom>
20            </owl:Restriction>
21       </owl:intersectionOf>
22    </owl:Class>
23  </owl:equivalentClass>
24  </owl:Class>
   <owl:Class rdf:about=“http://myNS#sheep”>
       <owl:Class rdf:about=“http://myNS#animal”/>
   <owl:Class rdf:about=“http://myNS#cow”>
       <owl:Class rdf:about=“http://myNS#vegetarian”/>

OWL’s use of formal semantics as well as a language feature-set that is richer than that of RDF-S, affords OWL models complex reasoning. One tradeoff of such reasoning is efficiency Table 1 contrasts OWL, and RDF, vis a vis reasoning

Needless to say, XHTML is not designed to provide, and does not provide, any of the mechanisms in Table 1.

Semantic Web Services

Service-Oriented Computing (SoC) and Service-Oriented Architectures have been receiving considerable attention recently and many view them as the emerging distributed computing model for the Internet applications. The Service-Oriented Architecture is manifested by Web Services, which are self-contained, self-describing, modular applications built from components and which may be instantiated on the Internet. The Web Services model develops a componentized view of web applications and is becoming the emerging platform for distributed computing. The standardization process is driven by the growing need to enable dynamic Business-to-Business (B2B) interactions on the Web. Those interactions require smooth choreography (or coordination, orchestration) of Web Services. The Service-Oriented Architecture considers a loosely coupled component model, where a Web Service interface (component) encapsulating any type of business logic is described in a standardized interface definition language, the Web Services Description Language (WSDL). Web Service components interact over an XML messaging protocol and interoperate with other components using the Simple Object Access Protocol (SOAP).

At the same time, Semantic Web Services combine Web Service standards, briefly outlined above, with semantic techniques, methods, and tools. The research domain of semantic Web Services is fairly new and, therefore, research has yielded many forms of prototypes, proposals and test-beds. The overall goal of initiatives under the semantic Web Services umbrella are to semantically enrich all activities carried out with Web Services, i.e., publishing, finding, and binding Web Services. This enrichment can be basically achieved by allowing for the attachment of semantic information to Web Services artifacts (documents). In related articles in this book we provide a brief overview of some research initiatives in the area of semantic Web Services.

Semantic Web Services - Intelligent Web Services, Web Service Technology [next] [back] Semantic Visual Query and Retrieval

User Comments

Your email address will be altered so spam harvesting bots can't read it easily.
Hide my email completely instead?

Cancel or