ontologies in the semantic web: logics, languages and more… pavel klinov

Ontologies in the Semantic Web: Logics, Languages and

more…

Pavel Klinov

What I am here for: To say few words about semantics and

ontologies Why they are important To present my biased view on ontologies

To give you an introduction into logical foundations of formal ontologies KR & R

To give a brief overview of the “state-of-the-art” ontological languages W3C standards, trends, challenges and more

(RDF(S), OWL)

Ontologies: Why Are They Important?

Imagine two communicating agents

Agent A tells:Red(X) Ambiguity

This apple is red Person is a Red

What the intended meaning is?

More generally: intended interpretation of a term is usually a small subset of all interpretations → need to specify it

Where’s Semantics on Web?

Semantic = Meaning. What things have meaning? Text, e.g., Web content Terms or expressions in agent dialogue Representation language

Key question: How can semantics be captured? Informally or Formally Implicitly or Explicitly

M. Uschold, “Where is the semantics in the Semantic Web”

Implicit vs Explicit Semantics Implicit

Explicit

Shared Human Consensus

Pump: “a device for moving a gas or liquid from one place or container to another”


Informal vs Formal Semantics Informal, e.g., NL descriptions

Formal, i.e., expressed in a formal language

The rest of the talk is about formal and explicit semantics

Pump: “a device for moving a gas or liquid from one place or container to another”

(pump has (superclasses (device,…))


Ontologies as Systems of Constraints (1)

A little more formal approach: Given an agent A using a language L with

vocabulary V There exists M(L) – set of all models of L But set of intended models of L according to A is

CA(L) - subset of M(L)M(L)

CA(L) conceptualization

N. Guarino, “Semantic Matching”

Now add a second agent - B In order to “understand” A, B must either share the same

conceptualization or A and B must adopt a common conceptualization

The key role of ontologies: they help establish a common conceptualization through placing semantic constraints on models of a language

Ontologies as Systems of Constraints (2)

M(L)

CA(L) conceptualization

CB(L)

N. Guarino, “Semantic Matching”

Logical Foundations of Formal Ontologies

Pavel Klinov

Why Logic?

Logic provides framework for defining: What are models What are semantic constraints How constraints can be formulated What are the consequences of placing

those constraints

Few logics have been investigated as ontology languages First-Order Logic Description Logic

Logics for ontologies

FOL + Expressive + Well understood - Undecidable - Doesn’t (naturally) support structured

concepts Example:

“Every human has two parents who are humans” ),(),()()()()( xzParentxyParentzyzHumanyzHumanyxxHuman

Logics for ontologies

Description Logic (DL) + Expressive + Well understood + Decidable (though worst case

intractable) + Supports structured knowledge - Less expressive than FOL Example:

“Every human has two parents who are humans”

HumanchildOfHuman .2

Syntax of the simplest DL - ALC Each concept defines

a term in a vocabulary

Concepts are defined using axioms: C =

A∩B DL allows creating

structured concepts from elementary (atomic) concepts

Ontology = collection of axioms (DL knowledge base)

I. Horrocks, U. Sattler, “DL: Basics, Applications and More”

Semantics of ALC DL has a declarative

model-theoretic semantics

Interpretation = <Universe, Interp.

Func.> Interpretation satisfies:

Axiom A = B iff AI = BI

Axiom A B iff AI BI

Ontology iff it satisfies all axioms

Important! DL semantics allows to state what is true without stating how to determine that

I. Horrocks, U. Sattler, “DL: Basics, Applications and More”

Back to models and constraints Models of a language M(L) = all possible

interpretations of given DL concepts Semantic constraints = DL axioms Intended models (conceptualization) =

interpretations that satisfy given DL ontology (set of axioms)

Examples: Lion Mammal is satisfied by LionI={1,2},

MammalI={1,2,3} Red Human is not satisfied by

RedI={red_colour}, HumanI={John,Abbey,Mike}

A=¬A is never satisfied

Knowledge Representation in DL Terminological Knowledge (TBox)

Concept definitions or inclusion axioms Man Human Man = Human ∩ Male

Assertional Knowledge (ABox) Concept and role membership axioms

John:Human parentOf(Jim,John)

Reasoning in the Semantic Web Reasoning can be used to support

ontology design and improve the quality of the resulting ontology

Reasoning can support ontology integration

Reasoning can be used by agents to determine set of facts consistent w.r.t. ontology

Ontology Design

Ontologies can be created step-by-step by computing “is-a” relationships between concepts

Person

Man Woman

Parent

GrandFather GrandMother

Father Mother

is-a

child

GrandFather is Father whose child is Parent

Ontology Integration Reasoning might be used to compute integrated hierarchy

and detect inconsistencies

Person

Adolescent

Boy Girl

is-a

Person

Man Woman

Parent

GrandFather GrandMother

Father Mother

is-a

has-child

Facts consistent w.r.t. ontology Reasoning can be used to classify

objects and infer their properties

Classification Tom is a parent of Jim and John is a son of

Jim. Therefore, Tom is a grandfather

Inferring properties Tom is a grandfather, so he must be at least

45 years of age

Reasoning in DL

Basic TBox inference problems: Concept Satisfiability: Concept C is satisfiable w.r.t. TBox

iff there exists an interpretation I of TBox s.t. CI is non-empty

Concept subsumption: C is subsumed by D w.r.t. TBox iff every interpretation I of TBox satisfies C D

Concept disjointness: C is disjoint with D w.r.t. TBox iff for every interpretation I of TBox CI is disjoint with DI

Examples: Is Man ∩ Man satisfiable w.r.t. an empty TBox? No

Is Man ∩ Woman satisfiable w.r.t. an empty TBox? Yes Man Person w.r.t. empty TBox? No Man Person w.r.t. T={PersonMan U Woman}? Yes!

Inference problems are interrelated C is subsumed by D iff (C ∩ D) is unsatisfiable

C and D are equivalent iff C is subsumed by D and vice versa

C and D are disjoint iff their intersection is unsatisfiable

All that is needed is a SAT solver for DL!

CIDI

DI

Satisfiability w.r.t. TBox

SAT w.r.t. generic TBoxes is difficult

At every logical step, reasoner must examine TBox to check that no axiom is violated

Sometimes the problem may be reduced to reasoning w.r.t. empty TBox

This may be done for simple terminologies using unfolding

Preconditions for Unfolding

Simple TBoxes Every concept appear every once in the left

handside of every axiom No cycles All left handsides are atomic

WomanParentMother

ManParentFather

PersonchildPersonParent

FemalePersonWoman

MalePersonMan

.

TreechildNodeTree .

Unfolding

Replace every non-basic concept in right handside by its definition

Example:ParentchildFatherrGrandFathe .

)..(

.

PersonchildPersonchildMan

PersonchildPersonrGrandFathe

ParentchildManParentrGrandFathe .

Tableau Reasoning for DLs

Goal: determine if concept is satisfiable

Try to construct model (tableau) for concept. If failed – concept is unsatisfiable

Tableau construction is accomplished by applying rules at every step of the reasoning process

Termination conditions: No rule can be applied - complete tableau Clash occurs, e.g, a:C and a:¬C – incomplete tableau

The procedure is provably sound, complete and

guaranteed to terminate

Tableau Expansion Rules

Intersection rule: Tableau contains a:(C ∩ D), then add a:C and a:D

Union rule: Tableau contains a:(C U D), then create two tableaux (one with a:C and another with a:D)

Universal restriction rule: Tableau contains a:(R.C) and (a,b):R, then add b:C

Existential restriction rule: Tableau contains a:(R.C), then add (a,b):R and b:C

Reasoning Example: Is (child.Male ∩ child.Female)

satisfiable?

1. K={a:(child.Male ∩ child.Female)}. Apply ∩-rule2. K=K{a:(child.Male), a:(child.Female)}. Apply -rule3. K=K{(a,b):child, b:Male}. Apply -rule4. K=K{(a,c):child, c:Female}

At this point no rule can be applied, no clash occurred, so the concept is satisfiable (a is Parent of both – Male b and Female c)

Another Reasoning Example: Is (child.Man ∩ child.Woman) satisfiable?

1. Unfolding: (child.Male ∩ child. Male)2. K={a:(child.Male ∩ child. Male)}. Apply ∩-rule3. K=K{a:(child.Male), a:( child. Male)}. Apply -rule4. K=K{(a,b):child, b:Male}. Apply -rule5. K=K{b:Male}

At this point, there is clash: b:Male and b: Male, so the concept is unsatisfiable

ABox Reasoning

Membership Does object belong to concept?

Retrieval Get all objects for given concept

Classification Get most specific concept for given object

Tableau procedure works the same way: a:C holds is a:C is unsatisfiable

DL Summary

DL is a logical reconstruction of earlier formalisms (Sem. Nets, Frames)

DL are translatable to other formalisms (FOL, Modal Logics)

Decision procedures exist and are known for most of DLs

DL research = balancing between expressiveness and decidability

Ontology Languages for the Semantic Web

Pavel Klinov

RDF

RDF stands for Resource Description Framework

It is a W3C candidate recommendation (http://www.w3.org/RDF)

RDF is graphical formalism ( + XML syntax + semantics) for representing metadata for describing the semantics of information in a

machine- accessible way

RDF document is a collection of triples (RDF graph)

I. Horrocks, “Ontology Languages for the Semantic Web”

RDF Semantics

RDF has “non-standard” semantics – mix of model-theoretic semantics, semantic conditions and axiomatic triples <rdf:subject, rdf:type, rdf:property> - axiomatic triple

Semantics given by RDF Model Theory (MT) (http://www.w3.org/TR/rdf-mt/)

In RDF MT, an interpretation I of a vocabulary V consists of: IR, a non-empty set of resources (universe) IS, a mapping from V into IR (interpretation function) IP, a distinguished subset of IR (the properties)

A vocabulary element v 2 V is a property iff IS(v) 2 IP IEXT, a mapping from IP into the powerset of IRxIR

I.e., property elements mapped to subsets of IRxIR IL, a mapping from typed literals into IR


RDF Semantics: Example

Satisfies: <a,b,c> <c,a,a> …

Doesn’t satisfy: <a,c,b>

c not a property

<a,b,b>(a,b) not in IEXT(1)

…

RDF W3C Standard - http://www.w3.org/TR/rdf-mt/

RDFS

RDF gives a formalism for meta data annotation, and a way to write it down in XML, but it does not give any special meaning to vocabulary such as subClassOf Interpretation is an arbitrary binary relation I.e., <Person,subClassOf,Animal> has no special meaning

RDF Schema defines “schema vocabulary” that supports definition of ontologies gives “extra meaning” to particular RDF predicates and

resources (such as subClassOf) this “extra meaning”, or semantics, specifies how a term

should be interpreted

RDFS is an RDF documenthttp://www.w3.org/TR/rdf-schema/rdfs-namespace/


RDFS Examples RDF Schema terms:

Class Property type subClassOf range domain

These terms are the RDF Schema building blocks (constructors) used to create vocabularies: <Person,type,Class> <hasColleague,type,Property> <Professor,subClassOf,Person> <Carole,type,Professor> <hasColleague,range,Person> <hasColleague,domain,Person>


RDFS Semantics

RDFS simply adds semantic conditions and axiomatic triples that give meaning to schema vocabulary

Class interpretation ICEXT simply induced by rdf:type, i.e.: x is in ICEXT(y) if and only if <x,y> is in IEXT(IS(rdf:type))

Other semantic conditions include: If <x,y> is in IEXT(IS(rdfs:domain)) and <u,v> is in IEXT(x)

then u is in ICEXT(y) If <x,y> is in IEXT(IS(rdfs:subClassOf)) then x and y are in IC

and ICEXT(x) is a subset of ICEXT(y) IEXT(IS(rdfs:subClassOf)) is transitive and reflexive on IC

Axiomatic triples include: rdf:type rdfs:domain rdfs:Resource rdfs:domain rdfs:domain rdf:Property


RDF(S): flexible and liberal

No distinction between classes and instances (individuals) <Species,type,Class> <Lion,type,Species> <Leo,type,Lion>

Properties can themselves have properties <hasDaughter,subPropertyOf,hasChild> <hasDaughter,type,familyProperty>

No distinction between language constructors and ontology vocabulary, so constructors can be applied to themselves/each other <type,range,Class> <Property,type,Class> <type,subPropertyOf,subClassOf>


Problems with RDFS

RDFS is too weak to describe resources in sufficient detail No localized range and domain constraints

Can’t say that the range of hasChild is person when applied to persons and elephant when applied to elephants

No existence/cardinality constraints Can’t say that all instances of person have a mother that is

also a person, or that persons have exactly 2 parents No transitive, inverse or symmetrical properties

Can’t say that isPartOf is a transitive property, that hasPart is the inverse of isPartOf or that touches is symmetrical

…

Difficult to provide reasoning support No “native” reasoners for non-standard semantics May be possible to reason via FO axiomatization

(http://www.w3.org/TR/lbase/)


Requirement for Web Ontology Language

Desirable features identified for Web Ontology Language:

Extends existing Web standards Such as XML, RDF, RDFS

Easy to understand and use Should be based on familiar KR idioms

Formally specified Of “adequate” expressive power Possible to provide automated reasoning

support

OWL

Ideally, OWL would extend RDF Schema Consistent with the layered architecture of

the Semantic Web

But simply extending RDF Schema would work against obtaining expressive power and efficient reasoning Combining RDF Schema with logic leads to

uncontrollable computational properties

G. Antoniou, F. van Harmelen, “Semantic Web Primer”

Three species of OWL

W3C’sWeb Ontology Working Group defined OWL as three different sublanguages: OWL Full OWL DL OWL Lite

Each sublanguage designed to fulfill different aspects of requirements

OWL Full It uses all the OWL languages primitives

owl:unionOf owl:equivalentClass owl:max(min)Cardinality …

It allows the combination of these primitives in arbitrary ways with RDF and RDF Schema

OWL Full is fully upward-compatible with RDF, both syntactically and semantically

OWL Full is so powerful that it is undecidable No complete reasoning support Example: cardinality restrictions on complex roles, e.g.,

>2ancestorOf.Person


OWL DL

OWL DL is a sublanguage of OWL Full that restricts application of the constructors from OWL and RDF Application of OWL’s constructors’ to each other is

disallowed Example:

EquivalentProperties(owl:sameAs,owl:differentFrom)

It corresponds to a well studied DL SHOIN(D)

OWL DL permits efficient reasoning support No full compatibility with RDF:

Not every RDF document is a legal OWL DL document. Every legal OWL DL document is a legal RDF document.


OWL Lite

An even further restriction limits OWL DL to a subset of the language constructors E.g., OWL Lite excludes enumerated classes,

disjointness statements, and arbitrary cardinality.

The advantage of this is a language that is easier to Understand, for users Implement, for tool builders Reason, for tools

The disadvantage is restricted expressivityG. Antoniou, F. van Harmelen, “Semantic Web Primer”

Upward Compatibility between OWL Species

Every legal OWL Lite ontology is a legal OWL DL ontology

Every legal OWL DL ontology is a legal OWL Full ontology

Every valid OWL Lite conclusion is a valid OWL DL conclusion

Every valid OWL DL conclusion is a valid OWL Full conclusion


OWL Syntactic Varieties

OWL builds on RDF and uses RDF’s XML-based syntax

Other syntactic forms for OWL have also been defined: An alternative, more readable XML-based

syntax (OWL/XML) An abstract syntax, that is much more

compact and readable than the XML languages (Lisp-like)

A graphic syntax based on the conventions of UML


Few OWL fragments…

Pavel Klinov

owl:Ontology <owl:Ontology rdf:about="">

<rdfs:comment>Some OWL ontology </rdfs:comment>

<owl:priorVersion

rdf:resource="http://www.uc.edu/uni-ns-0.1"/>

<owl:imports

rdf:resource=" http://www.uc.edu/uni-ns-1.0 "/>

<rdfs:label>University Ontology</rdfs:label>

</owl:Ontology>

owl:imports is a transitive property


Classes

Classes are defined using owl:Class

owl:Class is a subclass of rdfs:Class

Disjointness is defined using owl:disjointWith

<owl:Class rdf:about="#associateProfessor">

<owl:disjointWith rdf:resource="#professor"/>

<owl:disjointWith rdf:resource="#assistantProfessor"/>

</owl:Class> G. Antoniou, F. van Harmelen, “Semantic Web Primer”

Classes

owl:equivalentClass defines equivalence of classes

<owl:Class rdf:ID="faculty">

<owl:equivalentClass rdf:resource=“#academicStaffMember"/>

</owl:Class>

owl:Thing is the most general class (Top)

owl:Nothing is the empty class (Bottom)G. Antoniou, F. van Harmelen, “Semantic Web Primer”

Properties

In OWL there are two kinds of properties Object properties, which relate objects

to other objects E.g. taughtBy, supervises, parentOf

Data type properties, which relate objects to datatype values

E.g. phone, title, age, etc.


Datatype Properties

OWL makes use of XML Schema data types, using the layered architecture of the SW

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

<rdfs:range rdf:resource="http://www.w3.org/2001/XLMSchema

#nonNegativeInteger"/>

</owl:DatatypeProperty>


Inverse Properties

<owl:ObjectProperty rdf:ID="teaches">

<rdfs:range rdf:resource="#course"/>

<rdfs:domain rdf:resource= "#academicStaffMember"/>

<owl:inverseOf rdf:resource="#taughtBy"/>

</owl:ObjectProperty>


Special Properties owl:TransitiveProperty (transitive property)

E.g. “ancestorOf”

owl:SymmetricProperty (symmetry) E.g. “siblingOf”

owl:FunctionalProperty defines a property that has at most one value for each object

E.g. “age”

owl:InverseFunctionalProperty defines a property for which two different objects cannot have the same value

E.g. “passportNumber”


Open World Assumption

OWL currently adopts the open-world assumption (OWA): A statement cannot be assumed true on the basis

of a failure to prove it On Web, this is a reasonable assumption Example: Person = Human ∩ 2.hasParent.Human.

John:Human and parentOf(Jim,John), parentOf(Mary,John). Is John:Person entailed?

Closed-world assumption: a statement is true when its negation cannot be proved Leads to nonmonotonic behavior

Unique Names Assumption (UNA) Typical database applications assume that

individuals with different names are indeed

different individuals OWL follows the usual logical paradigm

where this is not the case Plausible on Web

Previous example: John:Human, parentOf(Jim,John),

parentOf(Mary,John). Is John:Person entailed?

Summary OWL is the proposed standard for Web

ontologies OWL builds upon RDF and RDF Schema: Formal semantics and reasoning support is

provided through the mapping of OWL to DL While OWL is sufficiently rich to be used in

practice, extensions are in the making OWL 1.1 being standardized (SROIQ(D))

Property chains Qualified cardinality restrictions Rich annotations

Rules (SWRL) Non-monotonic extensions (localized CWA, defaults) Handling uncertainty (ask me if interested!)

ontologies in the semantic web: logics, languages and more… pavel klinov

Documents

semantic web slide

semantic matching slide

humans slide

language ontologies

semantic constraints

owl slide

ontologies description

formal language