Ontology & OWL
Semantic Web - Fall 2005
Computer Engineering Department
Sharif University of Technology
Outline
Introduction & Definitions
 Ontology Languages
 OWL

Where does it come from?
 ontology n.
1692; lat. phil. onto- “being” + -logia
“study of”
 Philosophy


The study of what is, what has to be true
for something to exist, the kinds of things
that can exist
AI and computer science

Co-opted the term. Something exists if it
can be represented, described, defined (in a
formal, hence, machine-interpretable way).
Ontologies
Ontologies (contd.)



Ontologies are about vocabularies and their
meanings, with explicit, expressive, and welldefined semantics, possibly machineinterpretable.
“Ontology is a formal specification of a
conceptualization.” Gruber, 1993
Main elements of an ontology:


Concepts
Relationships




Hierarchical
Logical
Properties
Instances (individuals)
A Definition

Informal

Terms





from a specific domain
uniquely defined, usually via natural language
definitions
May contain additional semantics in the form of
informal relations
machine-processing is difficult
Examples



Controlled vocabulary
Glossary
Thesaurus
A Definition

Formal


Domain-specific vocabulary
Well-defined semantic structure

Classes/concepts/types
 E.g., a class { Publication } represents all publications
 E.g., a class { Publication } can have subclasses { Newspaper },
{ Journal }

Instances/individuals/objects
 E.g., the newspaper Le Monde is an instance of the class {
Newspaper }

Properties/roles/slots
 Data
 E.g., the class { Publication } and its subclasses {
Newspaper }, { Journal } have a data property {
numberOfPages }
 Object
 E.g., the class { Publication } and its subclasses {
Newspaper }, { Journal } have an object property {
publishes }

Is machine-processable
Ontologies in the Semantic Web
Provide shared data structures to
exchange information between agents
 Can be explicitly used as annotations in
web sites
 Can be used for knowledge-based
services using other web resources
 Can help to structure knowledge to
build domain models (for other
purposes)

Meaning is in Connections
is made from
G
a
m
e
Grape
a
i
n
r
f
W
Wine
m
s
d
e
i
e
r
o
p
For machines...
The meaning of the document is not defined.
Machines cannot understand it.
Wine is made from Grape
We are defining the structure of document by XML
but now the meaning of the structure is not defined.
<Sentence>
<Subject>
Wine
</Subject>
<Verb>
is made from
</Verb>
<Object>
Grape
</Object>
</Sentence>
XML document
<Sentence>
<Subject>
Wine
</Subject>
<Verb>
is made from
</Verb>
<Object>
Grape
</Object>
</Sentence>
Ontology gives the meaning...
Natural Language
Document
<Sentence>
<Subject>
Wine
</Subject>
<Verb>
is made from
</Verb>
<Object>
Grape
</Object>
</Sentence>
Ontology
Why develop ontologies?

To share knowledge


To reuse domain knowledge


E.g., geography ontology
To make domain assumptions explicit



E.g., using an ontology for integrating terminologies
Facilitate knowledge management
Enable new users to learn about the domain
To distinguish domain knowledge from operational
knowledge

e.g., biblio metadata
What they are good for

Informal

Controlled vocabulary


Upper-level structures for extending further


E.g., IRS information search
Search


E.g., AGRIS/CARIS categorization
Browsing support


Beginnings of interoperability
Limited query expansion
disambiguation

e.g., “Jordan” as a name of Basket-ball player
and name of a country
What they are good for

Formal

Search

Concept-based query
 User uses own words, language



Consistency checking


Related terms
Intelligent query expansion: “fishing vessels in
China” expands to “fishing vessels in Asia”
e.g., “Goods” has a property called “price” that has a
value restriction of number
Interoperability support

Terms defined in expressive ontologies allow for
mapping precisely how one term relates to another
Ontology Languages

Graphical notations





Semantic networks
Topic maps
UML
RDF
Logic based



Description Logics (e.g., OIL, DAML+OIL, OWL)
Rules (e.g., RuleML, LP/Prolog)
First Order Logic
Ontology Languages
•
•
•
•
•
•
•
RDF(S) (Resource Description Framework
(Schema))
OIL (Ontology Interchange Language)
DAML+OIL (DARPA Agent Markup
Language + OIL)
OWL (Ontology Web Language)
XOL (XML-based Ontology Exchange
Language)
SHOE (Simple HTML Ontology Extension)
OML (Ontology Markup Language)
Object oriented model

Many languages use object oriented model:

Objects/Instances/Individuals
 Elements of the domain of discourse
 Equivalent to constants in FOL

Types/Classes/Concepts
 Sets of objects sharing certain characteristics
 Equivalent to unary predicates in FOL and Concepts in
DL

Relations/Properties/Roles
 Sets of pairs (tuples) of objects
 Equivalent to binary predicates in FOL and Roles in DL
OWL (Ontology Web Language)

OWL is now a W3C Recommendation

The purpose of OWL is identical to RDFS i.e. to
provide an XML vocabulary to define classes,
properties and their relationships.



RDFS enables us to express very rudimentary
relationships and has limited inferencing capability.
OWL enables us to express much richer relationships,
thus yielding a much enhanced inferencing capability.
The benefit of OWL is that it facilitates a much
greater degree of inference than you get with RDF
Schema.
Origins of OWL
DARPA
Agent Markup DAML
Language
EU/NSF Joint Ad hoc
Committee
A W3C
Recommendation
OIL
Ontology
Inference
Layer
RDF
DAML+OIL
OWL
All
influenced
by RDF
OWL Lite
OWL DL
OWL Full
OWL

OWL and RDF Schema enable rich machine-processable
semantics
RDFS
OWL
Semantics
<rdfs:Class rdf:ID="River">
<rdfs:subClassOf rdf:resource="#Stream"/>
</rdfs:Class>
RDF Schema
XML/DTD/XML Schemas
Syntax
OWL
<owl:Class rdf:ID="River">
<rdfs:subClassOf rdf:resource="#Stream"/>
</owl:Class>
Why Build on RDF

Provides basic ontological primitives


Classes and relations (properties)
Class (and property) hierarchy

Can exploit existing RDF infrastructure

Provides mechanism for using ontologies


RDF triples assert facts about resources
Use vocabulary from DAML+OIL ontologies
OWL Design Goals
Shared ontologies
 Ontology evolution
 Ontology interoperability
 Inconsistency detection
 Expressivity vs. scalability
 Ease of use
 Compatibility with other standards
 Internationalization

Versions of OWL

Depending on the intended usage, OWL provides three
increasingly expressive sublanguages
OWL Full
OWL DL
OWL Lite
Full: Very expressive,
no computation guarantees
DL (Description Logic): Maximum
expressiveness, computationally
complete
Lite: Simple classification hierarchy
with simple constraints.
Comparison of versions

Full:




We get the full power of the OWL language.
It is very difficult to build a tool for this version.
The user of a fully-compliant tool may not get a quick and
complete answer.
DL/Lite:



Tools can be built more quickly and easily
Users can expect responses from such tools to come
quicker and be more complete.
We don't have access to the full power of the language.
Describing classes in OWL
OWL vs. RDFS

OWL allows greater expressiveness





Abstraction mechanism to group resources with
similar characteristics
Much more powerful in describing constraints on
relations between classes
Property transitivity, equivalence, symmetry, etc.
…
Extensive support for reasoning
OWL Ontologies

What’s inside an OWL ontology








Classes + class-hierarchy
Properties (Slots) / values
Relations between classes
(inheritance, disjoints, equivalents)
Restrictions on properties (type, cardinality)
Characteristics of properties (transitive, …)
Annotations
Individuals
Reasoning tasks: classification,
consistency checking
Classes

What is a Class?




e.g., person, pet, old
a collection of individuals (object, things, . . . )
a way of describing part of the world
an object in the world (OWL Full)
owl:Class
Sub class of Class in RDF
 Better to forget about classes of classes
 Top-most class: owl:Thing

<owl:Class rdf:ID=“Person"/>
<owl:Class rdf:ID=“Man">
<rdfs:subClassOf rdf:resource="#Person" />
</owl:Class>
Individuals

Two equivalent declarations:
1.
<Person rdf:ID=“Ganji" />
1.
<owl:Thing rdf:ID=“Ganji" />
<owl:Thing rdf:about="#Ganji">
<rdf:type rdf:resource="#Person"/>
</owl:Thing>
Properties

What is a Property?




e.g., has_father, has_pet, service_number
a collection of relationships between
individuals (and data)
a way of describing a kind of relationship
between individuals
an object in the world (OWL Full)
OWL Properties
Object
Properties
Data type
Properties
Ana  owns  Cuba
Ana  age  25
Is range a
literal / typed value ?
then ERROR

XML Schema data
types supported

DB people happy
Defining Properties






ObjectProperty
DatatypeProperty
rdfs:subPropertyOf
rdfs:domain
rdfs:range
<owl:ObjectProperty rdf:ID="madeFromGrape">
<rdfs:domain rdf:resource="#Wine"/>
<rdfs:range rdf:resource="#WineGrape"/>
</owl:ObjectProperty>
Describing classes in OWL
Complex Classes

Union of classes (owl:unionOf)


Union of classes (owl:intersectionOf)


OR (A  B)
AND (A  B)
Complement (owl:complementOf)

NOT

Enumeration (owl:oneOf)

Disjoint Classes (owl:disjointWith)
Describing classes in OWL
Property Restrictions


Defining a Class by restricting its possible
instances via their property values
OWL distinguishes between the following
two:
 Value constraint
 Cardinality constraint
Describing classes in OWL
Restrictions on Property Classes

Properties:
 allValuesFrom: rdfs:Class (lite/DL owl:Class)
 hasValue: specific Individual
 someValuesFrom: rdfs:Class (lite/DL owl:Class)
 minCardinality: xsd:nonNegativeInteger (in lite
{0,1})
 maxCardinality: xsd:nonNegativeInteger (in lite
{0,1})
What’s in OWL, but not in RDF
Ability to be distributed across many
systems
 Scalable to Web needs
 Compatible with Web standards for:




accessibility, and
Internationalization
Open and extensible
Describing properties in OWL
OWL vs. RDFS

RDF Schema provides some of predefined
properties:





OWL provides additional predefined properties:




rdfs:range used to indicate the range of values for a property.
rdfs:domain used to associate a property with a class.
rdfs:subPropertyOf used to specialize a property.
…
owl:cardinality (indicate cardinality)
owl:hasValue (at least one of the specified property values)
…
OWL provides additional property classes, which
allow reasoning and inferencing:



owl:FunctionalProperty
owl:TransitiveProperty
…
Describing properties in OWL
OWL Property Classes
rdf:Property
owl:ObjectProperty
owl:SymmetricProperty


owl:DatatypeProperty
owl:FunctionalProperty
owl:InverseFunctionalProperty
owl:TransitiveProperty
An ObjectProperty relates one Resource to another Resource.
A DatatypeProperty relates one Resource to a Literal - an XML
Schema data type.
Transitivity of properties
X  p1  Y
Y  p1  Z
implies X  p1  Z

Transitivity existed already in RDF


“subClassOf”, and ???
e.g. located_in, part_of
Symmetric properties
X  p1  Y
implies X  p1 Y

e.g.,
=
Functional Properties
X  p1  Y
X  p1  Z
imply Z is the same as Y
(they describe the same)
What if Y, Z
where explicitly defined as “different” ?
Inverse Functional Properties
Y  p1  A
Z  p1  A
imply Z is the same as Y
(they describe the same)
What if Y, Z
where explicitly defined as “different” ?
OWL distributed
“equivalent class”
“equivalent Property”
Guitar
Guitarra
Internationalization standards ?
Complex Classes
Female
Student
Professor
Married




Human
Male
Students
Married Female
Professors
Minority Students example


Married Female
Students
Divorced
Disjoint Classes

Married disjoint with:



Married
Divorced
Widowed
Single
Divorced

Widowed
Single
Are “Divorced” and “Single” disjoint ?
OWL Cardinality
min Cardinality
 max Cardinality


“Cardinality”


When
min = max
has Value

belongs to the class if it has the value
An Example OWL ontology
<owl:Class rdf:ID=“Person” />
<owl:Class rdf:ID=“Man”>
<rdfs:subClassOf rdf:resource=“#Person” />
<owl:disjointWith rdf:resource=“#Woman” />
</owl:Class>
<owl:Class rdf:ID=“Woman”>
<rdfs:subClassOf rdf:resource=“#Person” />
<owl:disjointWith rdf:resource=“#Man” />
</owl:Class>
<owl:Class rdf:ID=“Father”>
<rdfs:subClassOf rdf:resource=“Man” />
<owl:Restriction owl:minCardinality="1">
<owl:onProperty rdf:resource="#hasChild" />
</owl:Restriction>
</owl:Class>
<owl:ObjectProperty rdf:ID=“hasChild">
<rdfs:domain rdf:resource="#Parent" />
<rdfs:range rdf:resource="#Person" />
</owl:ObjectProperty>
References
http://www.w3.org/TR/owl-ref/
 Chapter 8 of the book

The End