Semantic Web - OWL

Semantic Web ::: Serge Linckels ::: http://www.linckels.lu/ ::: serge@linckels.lu
Semantic Web
Unit 6: Web Ontology Language
Faculty of Science, Technology and Communication (FSTC)
Bachelor en informatique (professionnel)

Semantic Web ::: Serge Linckels ::: http://www.linckels.lu/ ::: serge@linckels.lu 2
6. Web Ontology Language (OWL)
Semantic Web Roadmap:
Controlled growth bottom
up according to this
architecture.
Architecture was (slightly)
modified in the last years.

6.1. Ontologies and OWL
6.2. OWL Syntax
6.3. OWL expressivity
6.4. References

Semantic Web ::: Serge Linckels ::: http://www.linckels.lu/ ::: serge@linckels.lu
Limitations of RDF rdfs:Resource
foaf:Person
worksFor
age
myNS:Firm
How many firms can a person work for at
maximum?
Must every person work for a firm?
RDF allows to describe and serialize semantics in a machine readable form
RDF allows to reuse and share vocabularies
RDF is very limited in expressing restrictions over properties
Very limited reasoning services

Level of knowledge representation and semantics
XML / XML Schema
objects, structure
RDF / RDF Schema
knowledge about
objects, relations
between objects
OWL
domain knowledge,
interconnections

Level of knowledge representation and semantics
OWL
domain knowledge,
interconnections
An ontology is an explicit, formal specification of a
shared conceptualization (Thomas R. Gruber, 1993)
Conceptualization : abstract model of domain related expressions
Specification : domain related
Explicit : semantics of all expressions is clear
Formal : machine-readable
Shared : consensus (different people have different perceptions)

Web Ontology Language characteristics
OWL: W3C recommendation since 2004
Allows to define classes, instances of classes, properties and restriction over properties
OWL can be serialized as XML
No unique name assumption  if two objects are different, then this must be specified
explicitly
Example:
Woman  Person  Female
Man  Person  Male
Does not mean that Woman  Man
Woman  Person  Female
Man  Person  Male  Woman
Open World Assumption  what is not explicitly specified is not false
Example:
Woman(Barbara)
Is Barbara a woman? YES
Is Barbara a man? Don’t know
OWL2: W3C recommendation since 2009

6.2. OWL Syntax
Level of representation (example)
formal semantics of OWL (Description Logics syntax)
<owl:Class rdf:ID="Woman">
<rdfs:subClassOf rdf:resource="#Person">
</owl:Class>
Woman  Person
abstract syntax
class(a:Woman partial a:Person)
XML serializaion
Namespaces
<rdf:RDF
xmlns ="http://www.linckels.lu/demoOntology#"
xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:xsd ="http://www.w3.org/2001/XMLSchema#"
xmlns:rdfs ="http://www.w3.org/2000/01/rdf-schema#"
xmlns:owl ="http://www.w3.org/2002/07/owl#" >
...
</rdf:RDF>

6.2. OWL Syntax
Defining an ontology
<owl:Ontology rdf:about="">
<rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string">
This is an example of how to declare an ontology
</rdfs:comment>
<owl:versionInfo>v0.5</owl:versionInfo>
<owl:imports rdf:resource="http://www.linckels.lu/demo"/>
<owl:priorVersion rdf:resource="http://www.semweb.de/swrc"/>
</owl:Ontology>
OWL document header (example)
Inherited from RDF Schema Further OWL elements
rdfs:comment
rdfs:label
rdfs:seeAlso
rdfs:isDefinedBy
owl:versionInfo
owl:priorVersion
owl:backwardCompatibleWith
owl:incompatibleWith
owl:DeprecatedClass
owl:DeprecatedProperty
owl:imports

6.2. OWL Syntax
Classes in OWL
OWL classes are similar to RDFS classes
There exist 2 predefined classes:
• Thing : the top class () which contains all individuals
• Nothing : the bottom or empty class ()
Defining a class:
<owl:Class rdf:about="Woman" />
Individuals in OWL
OWL individuals are similar to RDFS objects
Defining an individual:
<rdf:Description rdf:about="Barbara">
<rdf:type rdf:resource="#Woman" />
</rdf:Description>
<Woman rdf:about="Barbara" />
=
<NamedIndividual rdf:about="Barbara">
<rdf:type rdf:resource="#Woman"/>
</NamedIndividual>

6.2. OWL Syntax
Roles in OWL
OWL roles are similar to RDFS properties
There exist 2 variants of properties:
• object properties : defining relations between classes
• datatype properties : defining property datatypes
Example of an object property:
<owl:ObjectProperty rdf:about="worksFor">
<rdfs:domain rdf:resource="#Person" />
<rdfs:range rdf:resource="#Firm" />
</owl:ObjectProperty>
Example of a datatype property:
<owl:DatatypeProperty rdf:about="age">
<rdfs:domain rdf:resource="#Person" />
<rdfs:range rdf:resource="&xsd;integer" />
</owl:DatatypeProperty>
rdfs:Resource
Person
worksFor
age
Firm

6.2. OWL Syntax
Roles in OWL
Example of an instance with roles:
<Firm rdf:about="BigCompany" />
<Person rdf:about="Barbara">
<age rdf:datatype="&xsd;integer">26</age>
<worksFor rdf:resource="#BigCompany" />
</Person>
rdfs:Resource
Person
worksFor
age
Firm
<NamedIndividual rdf:about="BigCompany">
<rdf:type rdf:resource="Firm"/>
</NamedIndividual>
<NamedIndividual rdf:about="Barbara">
<rdf:type rdf:resource="Person"/>
<age rdf:datatype="&xsd;integer">26</age>
<worksFor rdf:resource="#BigCompany" />
</NamedIndividual>

6.2. OWL Syntax
Hierarchy of classes
Inheritance as disjointness
<owl:Class rdf:about="Person" />
<owl:Class rdf:about="Woman">
<rdfs:subClassOf rdf:resource="#Person" />
</owl:Class>
<owl:Class rdf:about="Mother">
<rdfs:subClassOf rdf:resource="#Woman" />
</owl:Class>
<owl:Class rdf:about="Man">
<owl:disjointWith rdf:resource="#Woman" />
</owl:Class>
<owl:Class rdf:about="Father">
<rdfs:subClassOf rdf:resource="#Man" />
</owl:Class>
Logical inference allows to conclude that
• Mother is a sub-class of Person
• Father is disjoint with Mother
Person
Woman
Mother
Man
Father
Can a
woman
be a
man?

6.2. OWL Syntax
Hierarchy of classes
Equivalent classes
<owl:Class rdf:about="Personne">
<owl:equivalentClass rdf:resource="#Person">
</owl:Class>
<owl:Class rdf:about="Woman">
</owl:Class>
Logical inference allows to conclude that Woman is a
sub-class of Personne
Logical inference allows to conclude that Barbara is
also an instance of Personne
<Person rdf:about="Barbara" />
PersonPersonne
Woman
=

6.2. OWL Syntax
Special statements
Two individuals can be declared as being the same by linking them together, e.g.,
<owl:Person rdf:about="William_Jefferson_Clinton">
<owl:sameAs rdf:resource="BillClinton" />
</owl:Person>
Person
fullname
Two URIs actually refer to the same thing: the individuals have the
same "identity"
An owl:allDifferent statement allows to specify a list of individuals that are all disjoint
An owl:differentFrom statement indicates that two URIs refer to different individuals
<owl:AllDifferent>
<owl:distinctMembers rdf:parseType="Collection">
<Person rdf:about="#William_Jefferson_Clinton"/>
<Person rdf:about="#BillClinton"/>
<Person rdf:about="#President_Clinton"/>
</owl:distinctMembers>
</owl:AllDifferent>

6.2. OWL Syntax
Special statements
Declaration of a finite list of individuals
<owl:Class rdf:about="Continent">
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#Europe">
<owl:Thing rdf:about="#Asia">
<owl:Thing rdf:about="#Africa"/>
<owl:Thing rdf:about="#NorthAmerica"/>
<owl:Thing rdf:about="#SouthAmerica"/>
<owl:Thing rdf:about="#Australia"/>
</owl:oneOf>
</owl:Class>
Here, an instance of the class Continent can only be one of the indicated individuals, e.g.,
<Continent rdf:about="Europe" />

6.2. OWL Syntax
Special statements
Logical constructors over classes:
• owl:intersectionOf : conjunction of classes
• owl:unionOf : disjunction of classes
• owl:complementOf : negation
Such logical constructors are used to build complex classes from simple classes, e.g., to build
the following concept description:
Mother  Woman  hasChild.Person
simple class simple value restrictionconjunction
concept description for the new complex class Mother
A mother is a woman who has, among all other things, at least one child who is a person.

6.2. OWL Syntax
Restrictions over properties
Example:
To express that a Parent can only have a child that is a person, a
restriction over the property hasChild is required, formally:
Parent  hasChild.Person
<owl:ObjectProperty rdf:about="hasChild">
<rdfs:domain rdf:resource="#Parent" />
<rdfs:range rdf:resource="#Person" />
<owl:Class rdf:about="Parent">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild" />
<owl:allValuesFrom rdf:resource="#Person" />
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Using the universal quantifier ()
RDFS specification: the
value of the property goes
from Parent to Person
OWL restriction:
instances of the hasChild
property must have the
value Person

6.2. OWL Syntax
Example:
To express that a Parent has at least one child, and that child is a
person, a restriction over the property hasChild is required,
formally:
Parent  hasChild.Person
</owal:ObjectProperty>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild />
<owl:someValuesFrom rdf:resource="#Person" />
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Using the existential quantifier ()

6.2. OWL Syntax
Example:
To express that a Parent can only have a child that is a person, a
restriction over the property hasChild is required, formally:
Parent  hasChild.Person
<rdfs:subClassOf>
<owl:Restriction>
<owl:hasValue rdf:resource="#Person" />
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Special case of
owl:someValuesFrom
Specifying a fix value restriction for a property

6.2. OWL Syntax
Example:
To express that a Parent must have exactly 3 children a restriction
over the property hasChild is required, formally:
Parent  3hasChild
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild />
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">
3
</owl:cardinality>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
Exact cardinality specification
owl:minCardinality and
owl:maxCardinality allow to
specify the boundaries

6.2. OWL Syntax
Relations between properties
<owl:ObjectProperty rdf:about="hasParent">
<owl:inverseOf rdf:resource="#hasChild" />
Relations between properties can be expressed:
owl:subPropertyOf : specifying hierarchies of properties
owl:inverseOf : specifies inverse properties, e.g., isParentOf  hasChild–
owl:equivalentProperty : specifying identical properties
Defining advanced property characteristics:
owl:TransitiveProperty : R is transitive iff,
(x,y,z) R(x,y)  R(y,z)  R(x,z)
owl:SymmetricProperty : R is symmetric iff,
(x,y) R(x,y) iff R(y,x)
owl:FunctionalProperty : R is functional iff,
(x,y,z) R(x,y)  R(x,z)  y=z
owl:InverseFunctionalProperty: R is inverse functional iff,
(x,y,z) R(y,x)  R(z,x)  y=z

6.2. OWL Syntax
<owl:ObjectProperty rdf:about="isLocated">
<rdf:type rdf:resource="&owl;TransitiveProperty" />
<rdfs:domain rdf:resource="&owl;Thing" />
<rdfs:range rdf:resource="#Location" />
<Location rdf:about="EschAlzette">
<isLocated rdf:resource="#Luxembourg" />
</Location>
<Location rdf:about="Luxembourg">
<isLocated rdf:resource="#Europe" />
</Location>
<Location rdf:about="Europe" />
Example of a transitive property:
Esch/Alzette is located in Luxembourg and Luxembourg is located in Europe
Logical inference allows to conclude that Esch/Alzette is located in Europe

6.2. OWL Syntax
isColleagueOf isColleagueOf
isColleagueOf
(by logical induction)
isColleagueOf = transitive
hasBoss= functional
?
isBossOf = inverse functional
=
(by logical
induction)

6.2. OWL Syntax
<owl:ObjectProperty rdf:about="isColleagueOf">
<rdf:type rdf:resource="&owl;TransitiveProperty" />
<owl:ObjectProperty rdf:about="hasBoss">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
<Lab rdf:about="http://www.uni.lu/lassy/">
<hasBoss rdf:resource="http://www.zampunieris.be/" />
<hasBoss rdf:resource="http://www.kelsen.lu/" />
</Lab>
<Teacher rdf:about="http://www.zampunieris.be/">
<isColleagueOf rdf:resource="http://www.kelsen.lu/" />
</Teacher>
<Teacher rdf:about="http://www.kelsen.lu/">
<isColleagueOf rdf:resource="http://www.linckels.lu/" />
</Teacher>

6.2. OWL Syntax
<owl:ObjectProperty rdf:about="hasUncle">
<owl:propertyChainAxiom rdf:parseType="Collection">
<owl:ObjectProperty rdf:resource="hasParent" />
<owl:ObjectProperty rdf:about="hasBrother" />
</owl:propertyChainAxiom>
OWL2 allows role chains
Example:
The brother of my parent is my uncle.
hasUncle  hasParent ◦ hasBrother

6.2. OWL Syntax
Building concept descriptions
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Person"/>
<rdf:subClassOf>
<owl:Restriction>
<owl:someValuesFrom rdf:resource="#Person" />
</owl:Restriction>
</rdf:subClassOf>
</owl:intersectionOf>
</owl:Class>
Building concept descriptions means creating an intersection of concepts and value restrictions
Example 1:
A Parent is a Person and has at least one child, and that child is a person, formally:
Parent  Person  hasChild.Person

6.2. OWL Syntax
Building concept descriptions
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:allValuesFrom>
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Doctor"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:someValuesFrom rdf:resource="#Doctor"/>
</owl:Restriction>
</owl:unionOf>
</owl:allValuesFrom>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
Example 2: Person  hasChild.(Doctor  hasChild.Doctor)

6.2. OWL Syntax
Summary
OWL DL implements DL

OWL and Description Logics
Complete list of differences:
http://www.w3.org/TR/owl-ref/#Sublanguage-def
OWL Full
OWL DL
OWL
Lite
OWL exists in three variants with a different degree of expressivity:
OWL Lite
•classification hierarchy
•simple constraints
•cardinality constraints
•cardinality values [0..1]
•no container classes
•no disjunction
•simple computable and
decidable inferences
•complexity: ExpTime
(worst case)
OWL DL
•based on DL
•includes all OWL
language constructs
•several limitations, e.g.,
no reification
•computable and
decidable inferences
•complexity: NExpTime
(worst case)
OWL Full
•highest level of
expressivity
•a class can be treated
simultaneously as a
collection of individuals,
and as an individual in its
own right
•allows an ontology to
augment the meaning of
the pre-defined (RDF or
OWL) vocabulary.
•complex reasoning
allowed but no guarantee
to be computable and
decidable

OWL Full
OWL Full
OWL DL
OWL
Lite
All DL and RDF(S) elements
No difference between classes, roles and individuals
• owl:Thing is the same than rdfs:resource
• owl:Class is the same than rdfs:Class
• owl:DatatypeProperty is a sub-class of owl:ObjectProperty
• owl:ObjectProperty is the same than rdf:Property
OWL DL
Not all RDF(S) elements are allowed, e.g., not allowed: rdfs:class and rdfs:Property
Classes and roles are separated
Roles cannot be transitive, symmetric, inverse or functional inverse
OWL Lite
Not allowed elements: oneOf, unionOf, complementOf, hasValue, and disjointWith
Restriction over properties allow only cardinalities of 0 and 1

OWL and Description Logics
OWL DL-sublanguages:
OWL Full
OWL DL
OWL
Lite
 :  and + (transitive roles)
 : for role hierarchy, e.g., hasDaugher  hasChild
 : for nominals/singleton classes, e.g., Luxembourg(Luxembourg)
 : for inverse roles, e.g., isChildOf  hasChild–
 : for number restrictions, e.g., ≤2hasChild
 : for qualified number restriction, e.g., ≤hasChild.Doctor
OWL Lite is (D), where D stands for a datatype theory
OWL DL is (D), where D stands for a datatype theory
Datatype theory D is a mapping from a set of datatypes to a set of values, plus a mapping
from data values to their denotation
Example:
Expressing that 1 represents an integer value: "1"^^xsd:integer

6.4. References
Semantic Web: Concepts,
Technologies and
Applications
K.K. Breitman, M.A. Casanova,
W. Truszkowski
Handbook on Ontologies
Steffen Staab, Rudi Studer
Foundations of Semantic Web
Technologies
Pascal Hitzler, Markus Krötzsch,
Sebastian Rudolph
E-Librarian Service
User-Friendly Semantic
Search in Digital
Libraries
Serge Linckels, Christoph
Meinel

Semantic Web - OWL

Recommended

Recommended

More Related Content

What's hot

What's hot (18)

Similar to Semantic Web - OWL

Similar to Semantic Web - OWL (20)

More from Serge Linckels

More from Serge Linckels (13)

Recently uploaded

Recently uploaded (20)

Semantic Web - OWL