Unit 4 Ontology

4.1 Semantic Data and Web

What is Semantic Data?

The semantic data model is a software engineering model based on relationships between stored
symbols and the real world.
The data is organized in such a way that it can be interpreted meaningfully without human
intervention. Semantic data has a history dating back to the 1970's and is currently used in a wide
variety of data management systems and applications.

How Does Semantic Data Work?

Data is organized based on binary models of objects, usually in groups of three parts: two objects
and their relationship. For example, if one wanted to represent a cup sitting on a table, the data
organization might look like this: CUP TABLE. The objects (cup and table) are interpreted with regard
to their relationship (sitting on). The data is organized linearly, telling the software that since CUP
comes first in the line, it is the object that acts. In other words, the position of the word tells the
software that the cup is on the table and not that the table is sitting on the cup. Databases designed
around this concept have greater applicability and are more easily integrated into other databases.

What Is the Semantic Web?

The Semantic Web is a vision about an extension of the existing World Wide Web, which provides
software programs with machine-interpretable metadata of the published information and data. In
other words, we add further data descriptors to otherwise existing content and data on the Web. As
a result, computers are able to make meaningful interpretations similar to the way humans process
information to achieve their goals.

What is an ontology?

An ontology is a way in which to describe the world. From one perspective, language is an ontology;
a set of labels to give meaning to real world things.
An ontology is an explicit specification of a conceptualization. The term is borrowed from
philosophy, where an Ontology is a systematic account of Existence. For AI systems, what "exists" is
that which can be represented. When the knowledge of a domain is represented in a declarative
formalism, the set of objects that can be represented is called the universe of discourse. This set of
objects, and the describable relationships among them, are reflected in the representational
vocabulary with which a knowledge-based program represents knowledge. Thus, in the context of
AI, we can describe the ontology of a program by defining a set of representational terms. In such an
ontology, definitions associate the names of entities in the universe of discourse (e.g., classes,
relations, functions, or other objects) with human-readable text describing what the names mean,
and formal axioms that constrain the interpretation and well-formed use of these terms. Formally,
an ontology is the statement of a logical theory.

Example:

A general example may help. A bookseller may want to integrate data coming from different
publishers. The data can be imported into a common RDF model, eg, by using converters to the
publishers’ databases. However, one database may use the term “author”, whereas the other may
use the term “creator”. To make the integration complete, and extra definition should be added to
the RDF data, describing the fact that the relationship described as “author” is the same as
“creator”. This extra piece of information is, in fact, a vocabulary (or an ontology), albeit an
extremely simple one.

In a more complex case the application may need a more detailed ontology as part of the extra
information. This may include formal description on how authors are to be uniquely identified (eg, in
a US setting, by referring to a unique social security number), how the terms used in this particular
application relate to other datasets on the Web (eg, Wikipedia or geographic information), how the
term “author” (or “creator”) can be related to terms like “editors”, etc.

What is RDF?

 In the Semantic Web we refer to the things in the world as resources; a resource can be
anything that someone might want to talk about.
 Resource is the word used in the Semantic Web standards. the name of the base technology
in the Semantic Web (RDF) uses this word in an essential way. RDF stands for Resource
Description Framework.
 In a web of information, anyone can contribute to our knowledge about a resource. It was
this aspect of the current Web that allowed it to grow at such an unprecedented rate. To
implement the Semantic Web, we need a model of data that allows information to be
distributed over the Web. RDF can represent data in a distributed way across the Web.
RDF Example:

<rdf:RDF
xmlns:mfg¼"http://www.WorkingOntologist.com/Examples/Chapter3/
Manufacturing.rdf#"
xmlns:rdf¼"http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<mfg:Product
rdf:about¼"http://www.WorkingOntologist.com/Examples/Chapter3/
Manufacturing.rdf#Product1">
<mfg:Available>23</mfg:Available>
<mfg:Division>Manufacturing support</mfg:Division>
<mfg:ProductLine>Paper machine</mfg:ProductLine>
<mfg:SKU>FB3524</mfg:SKU>
<mfg:ModelNo>ZX-3</mfg:ModelNo>
<mfg:ManufactureLocation>Sacramento</mfg:Manufacture
Location>
</mfg:Product>
<mfg:Product
rdf:about¼"http://www.WorkingOntologist.com/Examples/Chapter3/
Manufacturing.rdf#Product2">
<mfg:SKU>KD5243</mfg:SKU>
<mfg:Division>Manufacturing support</mfg:Division>
<mfg:ManufactureLocation>Sacramento</mfg:Manufacture
Location>
<mfg:Available>4</mfg:Available>
<mfg:ModelNo>ZX-3P</mfg:ModelNo>
<mfg:ProductLine>Paper machine</mfg:ProductLine>
</mfg:Product>

</rdf:RDF>

4.2 Semantic Web Application Architecture

Main Components in Semantic Web Application Architecture

Main tools:

1. RDF parsers, serializers and converters

2. RDF Store (sometimes called Triple Store)
3. RDF Query Engine

RDF Parsers & Serializers

 An RDF parser reads text in one (or more) of these formats and interprets it as triples in the
RDF data model. An RDF serializer does the reverse; it takes a set of triples and creates a file
that expresses that content in one of the serialization form.
 Parser : RDF can be in XML/RDF or Turtle format, Parser converts in into an RDF graph.
 Serializer: does the opposite: from a graph it creates a serialized version of it.
 RDF Converters: Sometimes the data source is not in RDF form.
 e.g. relational databases, spreadsheets but also can be micro formats - special attributes in
HTML tags (business cards or events)
 or RDFa - same idea, embed RDF into HTML attributes
o to have machine-processable HTML data

RDF Store

 This is a database tuned for storing and retrieving triples. Also should have an ability to
merge information from multiple data sources (unlike Relational Databases)

RDF Query Engine

 Closely related to #RDF Store

 The query engine provides the capability to retrieve information from an RDF store
according to structured queries.

4.3 Overview and structure of Web Ontology Language

Introduction

 The OWL Web Ontologoy Language is a language for defining and instantiating Web
ontologies. Ontology is a term borrowed from philosophy that refers to the science of
describing the kinds of entities in the world and how they are related.
 An OWL ontology may include descriptions of classes, properties and their instances. Given
such an ontology, the OWL formal semantics specifies how to derive its logical
consequences.
 i.e. facts not literally present in the ontology, but entailed by the semantics.
 These entailments may be based on a single document or multiple distributed documents
that have been combined using defined OWL mechanisms.

The Structure of Ontology

A structure contains following.

1. Namespaces
 A standard initial component of an ontology includes a set of XML namespace declarations
enclosed in an opening rdf:RDF tag.
 These provide a means to unambiguously interpret identifiers and make the rest of the
ontology presentation much more readable.
 A typical OWL ontology begins with a namespace declaration similar to the following.

<rdf:RDF
xmlns ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#"
xmlns:vin ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#"
xml:base ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#"
xmlns:food="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#"
xmlns:owl ="http://www.w3.org/2002/07/owl#"
xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd ="http://www.w3.org/2001/XMLSchema#">

 As an aid to writing lengthy URLs it can often be useful to provide a set of entity definitions
in a document type declaration (DOCTYPE) that precedes the ontology definitions.
 The names defined by the namespace declarations only have significance as parts of XML
tags. Attribute values are not namespace sensitive. But in OWL we frequently reference
ontology identifiers using attribute values.
 They can be written down in their fully expanded form, for example
"http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#merlot". Alternatively,
abbreviations can be defined using an ENTITY definition, for example:

<!DOCTYPE rdf:RDF [
<!ENTITY vin "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" >
<!ENTITY food "http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" > ]>

 After this pair of ENTITY declarations, we could write the value "&vin;merlot" and it would
expand to "http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#merlot".
  Perhaps more importantly, the rdf:RDF namespace declarations can then be simplified so
that changes made to the entity declarations will propagate through the ontology
consistently.

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

2. Ontology Headers
 Once namespaces are established we normally include a collection of assertions about the
ontology grouped under an owl:Ontology tag.
 These tags support such critical housekeeping tasks as comments, version control and
inclusion of other ontologies.

<owl:Ontology rdf:about="">
<rdfs:comment>An example OWL ontology</rdfs:comment>
<owl:priorVersion rdf:resource="http://www.w3.org/TR/2003/PR-owl-guide-
20031215/wine"/>
<owl:imports rdf:resource="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food"/>
<rdfs:label>Wine Ontology</rdfs:label>

 The owl:Ontology element is a place to collect much of the OWL meta-data for the
document.
 The rdf:about attribute provides a name or reference for the ontology.
 rdfs:comment provides the obvious needed capability to annotate an ontology.
 owl:priorVersion is a standard tag intended to provide hooks for version control systems
working with ontologies.
 owl:imports provides an include-style mechanism.
 We also include an rdfs:label to support a natural language label for our ontology.

 he ontology header definition is closed with the following tag.

</owl:Ontology>

3. Data Aggregation and Privacy

 OWL's ability to express ontological information about instances appearing in multiple
documents supports linking of data from diverse sources in a principled way.
 In particular, the ability to express equivalences using owl:sameAs can be used to state that
seemingly different individuals are actually the same. Owl:InverseFunctionalProperty can
also be used to link individuals together.
 For example, if a property such as "SocialSecurityNumber" is an
owl:InverseFunctionalProperty, then two separate individuals could be inferred to be
identical based on having the same value of that property.
 When individuals are determined to be the same by such means, information about them
from different sources can be merged.
  This aggregation can be used to determine facts that are not directly represented in any one
source.
 The capability to merge data from multiple sources, combined with the inferential power of
OWL, does have potential for abuse. Users of OWL should be alert to the potential privacy
implications.

4.4 Components of Web Ontology Language - Individuals, Properties and

Classes

Simple Named Classes

 The most basic concepts in a domain should correspond to classes that are the roots of various
taxonomic trees.

 Every individual in the OWL world is a member of the class owl:Thing. Thus each user-defined
class is implicitly a subclass of owl:Thing. Domain specific root classes are defined by simply
declaring a named class. OWL also defines the empty class, owl:Nothing.

 For sample wines domain, we create three root classes: Winery, Region, and ConsumableThing.

<owl:Class rdf:ID="Winery"/>
<owl:Class rdf:ID="Region"/>
<owl:Class rdf:ID="ConsumableThing"/>
The syntax rdf:ID="Region" is used to introduce a name, as part of its definition.

 The fundamental taxonomic constructor for classes is rdfs:subClassOf.

 It relates a more specific class to a more general class. If X is a subclass of Y, then every instance
of X is also an instance of Y.

 The rdfs:subClassOf relation is transitive. If X is a subclass of Y and Y a subclass of Z then X is a

subclass of Z.

<owl:Class rdf:ID="PotableLiquid">
<rdfs:subClassOf rdf:resource="#ConsumableThing" />
...
</owl:Class>

 We define PotableLiquid (liquids suitable for drinking) to be a subclass of ConsumableThing.

Individuals

 An individual is minimally introduced by declaring it to be a member of a class.

 <Region rdf:ID="CentralCoastRegion" />

 Note that the following is identical in meaning to the example above.

<owl:Thing rdf:ID="CentralCoastRegion" />

<owl:Thing rdf:about="#CentralCoastRegion">
<rdf:type rdf:resource="#Region"/>
</owl:Thing>

 rdf:type is an RDF property that ties an individual to a class of which it is a member.

Example:

In order to have available a few more classes for the properties introduced in the further sections,
we define a branch of the Grape taxonomy, with an individual denoting the Cabernet Sauvignon
grape varietal. Grapes are defined in the food ontology:

<owl:Class rdf:ID="Grape">
...
</owl:Class>

And then in the wine ontology we have:

<owl:Class rdf:ID="WineGrape">
<rdfs:subClassOf rdf:resource="&food;Grape" />
</owl:Class>

<WineGrape rdf:ID="CabernetSauvignonGrape" />

Properties

 A property is a binary relation. Two types of properties are distinguished: datatype properties,
relations between instances of classes and RDF literals and XML Schema datatypes, object
properties, relations between instances of two classes.
 Note that the name object property is not intended to reflect a connection with the RDF term
rdf:object ([RDF]
 Properties, like classes, can be arranged in a hierarchy.

<owl:Class rdf:ID="WineDescriptor" />

<owl:Class rdf:ID="WineColor">
<rdfs:subClassOf rdf:resource="#WineDescriptor" />
...
</owl:Class>

<owl:ObjectProperty rdf:ID="hasWineDescriptor">
<rdfs:domain rdf:resource="#Wine" />
<rdfs:range rdf:resource="#WineDescriptor" />
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="hasColor">
<rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" />
<rdfs:range rdf:resource="#WineColor" />
 ...
</owl:ObjectProperty>

 WineDescriptor properties relate wines to their color and components of their taste,
including sweetness, body, and flavor.
 hasColor is a subproperty of the hasWineDescriptor property, with its range further
restricted to WineColor.
 The rdfs:subPropertyOf relation in this case means that anything with a hasColor property
with value X also has a hasWineDescriptor property with value X.

 Next we introduce the locatedIn property, which relates things to the regions they are
located in.

<owl:ObjectProperty rdf:ID="locatedIn">
...
<rdfs:domain rdf:resource="http://www.w3.org/2002/07/owl#Thing" />
<rdfs:range rdf:resource="#Region" />
</owl:ObjectProperty>

 The domain permits anything to be located in a region, including regions themselves.

Types of Properties

1. TransitiveProperty

 If a property, P, is specified as transitive then for any x, y, and z:

 P(x,y) and P(y,z) implies P(x,z)

Example:

The property locatedIn is transitive.

<owl:ObjectProperty rdf:ID="locatedIn">
<rdf:type rdf:resource="&owl;TransitiveProperty" />
<rdfs:domain rdf:resource="&owl;Thing" />
<rdfs:range rdf:resource="#Region" />
</owl:ObjectProperty>

<Region rdf:ID="SantaCruzMountainsRegion">
<locatedIn rdf:resource="#CaliforniaRegion" />
</Region>

<Region rdf:ID="CaliforniaRegion">
<locatedIn rdf:resource="#USRegion" />
</Region>

Because the SantaCruzMountainsRegion is locatedIn the CaliforniaRegion, then it must also be

locatedIn the USRegion, since locatedIn is transitive.
2. SymmetricProperty

 If a property, P, is tagged as symmetric then for any x and y:

 P(x,y) iff P(y,x)

 The property adjacentRegion is symmetric, while locatedIn is not. To be more precise,

locatedIn is not intended to be symmetric. Nothing in the wine ontology at present prevents
it from being symmetric.

<owl:ObjectProperty rdf:ID="adjacentRegion">
<rdf:type rdf:resource="&owl;SymmetricProperty" />
<rdfs:domain rdf:resource="#Region" />
<rdfs:range rdf:resource="#Region" />
</owl:ObjectProperty>

<Region rdf:ID="MendocinoRegion">
<locatedIn rdf:resource="#CaliforniaRegion" />
<adjacentRegion rdf:resource="#SonomaRegion" />
</Region>

The MendocinoRegion is adjacent to the SonomaRegion and vice-versa. The MendocinoRegion is

located in the CaliforniaRegion but not vice versa.

3. FunctionalProperty

If a property, P, is tagged as functional then for all x, y, and z:

P(x,y) and P(x,z) implies y = z

In our wine ontology, hasVintageYear is functional. A wine has a unique vintage year. That is, a given
individual Vintage can only be associated with a single year using the hasVintageYear property. It is
not a requirement of a owl:FunctionalProperty that all elements of the domain have values. See the
discussion of Vintage cardinality.

<owl:Class rdf:ID="VintageYear" />

<owl:ObjectProperty rdf:ID="hasVintageYear">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
<rdfs:domain rdf:resource="#Vintage" />
<rdfs:range rdf:resource="#VintageYear" />
</owl:ObjectProperty>

4. 4. inverseOf

If a property, P1, is tagged as the owl:inverseOf P2, then for all x and y:

P1(x,y) iff P2(y,x)

Note that the syntax for owl:inverseOf takes a property name as an argument. A iff B means (A
implies B) and (B implies A).
<owl:ObjectProperty rdf:ID="hasMaker">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="producesWine">
<owl:inverseOf rdf:resource="#hasMaker" />
</owl:ObjectProperty>