Dr. Hoang Huu Hanh, OST - Hue University hanh-at-hueuni.edu.vn - - PowerPoint PPT Presentation

SLIDE 1

• Dr. Hoang Huu Hanh, OST - Hue University

hanh-at-hueuni.edu.vn

SLIDE 2

Cl ifi ti

 Clarification:

• What are Ontologies?

R i it d

 Revisited:

• How we already have learned to express ontologies

W b O l L OWL

 Web Ontology Language ‐OWL:

• extending expressivity

f

 Semantics of & Reasoning with OWL:

• using the extended expressivity

2

SLIDE 3

 “Ontology” in Philosophy:

“Th t h i l t d f th t f b i

• “The metaphysical study of the nature of being

and existence”

 “Ontology” in Artificial Intelligence:

• a shared and common understanding of some

domain that can be communicated between people and application systems” – (Gruber)

3

SLIDE 4

“O t l (l )” f th S ti W b



“Ontology (languages)” for the Semantic Web: We aim at a (XML‐based) language to formally describe t i t l ti d i i d t t t concepts, instances, relations and axioms, i.e. data+structure in order to enable machine‐processable reasoning on and exchange of data.  Knowledge representation, exchange, combination (inference of new knowledge!)

4

SLIDE 5

 Concepts Classes + class hierarchy  Concepts: Classes + class‐hierarchy

• instances

 Properties: often also called “Roles” or “Slots”

• labeled instance‐value‐pairs
• labeled instance‐value‐pairs

 Axioms/Relations:

• relations between classes (disjoint, covers)
• inheritance (multiple? defaults?)

( p )

• restrictions on slots (type, cardinality)
• Characteristics of slots (symm., trans., …)

 reasoning tasks:

• Classification: Which classes does an instance belong to?
• Subsumption: Does a class subsume another one?
• Consistency checking: Is there a contradiction in my

axioms/instances? axioms/instances?

5

SLIDE 6

W b t l

 Web portal

• ontology‐based portal for a community of users which have shared

interest

M lti di ll ti

 Multi‐media collections

• annotating, searching, ontological search instead of keyword search

 Corporate Website

p

• knowledge management

 Documentation

• engineering & design
• engineering & design

 Agents & Services, Ubiquitous computing

• Interoperability!

6

SLIDE 7

Cl ifi ti

 Clarification:

• What are Ontologies?

R i it d

 Revisited:

• How we already have learned to express ontologies

W b O l L OWL

 Web Ontology Language ‐OWL:

• extending expressivity

f

 Semantics of & Reasoning with OWL:

• using the extended expressivity

7

SLIDE 8

RDF triples for making assertions abo t reso rces

 RDF: triples for making assertions about resources  RDFS extends RDF with “schema vocabulary”, e.g.:

• Class, Property
• type, subClassOf, subPropertyOf
• range, domain

 representing simple assertions, taxonomy + typing

Vehicle LandVehicle SeaVehicle Hovercraft Company subClassOf subClassOf subClassOf subClassOf

NumberOfEngines

Number

8

SLIDE 9



RDFS too weak to describe resources in sufficient detail:



RDFS too weak to describe resources in sufficient detail:

• No localised 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

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

• No in/equality

C ’t th t l /i t i th th l /i t ▪ Can’t say that a class/instance is the same as some other class/instance, can’t say that somthe classes/instances are definitely disjoint/different.

• No boolean algebra

▪ Can’t say that that one class is the union, intersection, complement of y p

• ther classes, etc.

9

SLIDE 10

??? ???

 Semantics+reasoning

??? D t E h

 Semantics+reasoning

 Relational Data ? OWL  Data Exchange

10

SLIDE 11

Cl ifi ti

 Clarification:

• What are Ontologies?

R i it d

 Revisited:

• How we already have learned to express ontologies

W b O l L OWL

 Web Ontology Language ‐OWL:

• extending expressivity

f

 Semantics of & Reasoning with OWL:

• using the extended expressivity

11

SLIDE 12

 Both use the same data model:  Both use the same data model:

page.html “Dieter Fensel“ hasAuthor Resource (subject) Property (predicate) Value (object)

 OWL extends vocabulary and adds axioms

(subject) (predicate) (object)

12

SLIDE 13

DAML OIL RDF DAML+OIL

13

OWL

SLIDE 14

T l d l d i f b i



Two languages developed to satisfy above requirements

• OIL (Object Inference Layer): developed by group of (largely) European

researchers (several from EU OntoKnowledge project)

• DAML‐ONT: developed by group of (largely) US researchers (in DARPA DAML

programme)



Efforts merged to produce DAML+OIL

• Development was carried out by “Joint EU/US Committee on Agent Markup

Languages”

• Extends (“DL subset” of) RDF



DAML+OIL submitted to W3C as basis for standardisation

• Web‐Ontology (WebOnt) Working Group formed
• WebOnt group developed OWL language based on DAML+OIL

g p p g g

• OWL language now a W3C Recommendation (01.02.2004)

14

SLIDE 15

 OWL Lite F ll

• (sub)classes, individuals
• (sub)properties, domain, range
• intersection
• (in)equality

RDF Schema

Full DL

(in)equality

• cardinality 0/1
• datatypes
• inverse, transitive, symmetric

h l

Lite

• hasValue
• someValuesFrom
• allValuesFrom

 OWL Full  OWL DL  OWL Full

• Allow meta‐classes etc

 OWL DL

• Negation (disjointWith, complementOf)
• unionOf
• Full Cardinality

15

Full Cardinality

• Enumerated types (oneOf)

SLIDE 16



Three species of OWL

Full



Three species of OWL

• OWL DL stays in Description Logic fragment
• OWL Lite is “easier to implement” subset of OWL DL
• OWL Full is union of OWL syntax and RDF

Full DL

OWL Full is union of OWL syntax and RDF



OWL DL based on SHIQ Description Logic

• In fact it is equivalent to SHOIN(Dn) DL

Lite



OWL DL Benefits from many years of DL research

• Well defined semantics
• Formal properties well understood (complexity, decidability)
• Known reasoning algorithms
• Implemented systems (highly optimised)

OWL f ll h ll th t d ll th ibiliti



OWL full has all that and all the possibilities

• f RDF/RDFS which destroy decidability

16

SLIDE 17



DLs are a family of logic based KR formalisms



DLs are a family of logic based KR formalisms



Particular languages mainly characterized by:

• Set of constructors for building complex concepts and roles from simpler ones
• Set of axioms for asserting facts about concepts, roles and individuals



Examples:

• “Female persons”

▪ Person ⊓ Female

• “Non‐female persons”

Non female persons

▪ Person ⊓ Female

• “Persons that have a child”

▪ Person ⊓ hasChild.Person

• “Persons all of whose children are female”

Persons all of whose children are female

▪ Person ⊓ hasChild.Female

• “Persons that are employed or self‐eployed”

▪ Person ⊓ (Employee ⊔ SelfEmployed)

• “Persons the have at most one father“

Persons the have at most one father

▪ Person ⊓ ≤1.hasFather

17

SLIDE 18

 Inclusion axioms provide necessary

conditions:

• concept ⊑ definition

 Equivalence axioms provide necessary and

sufficient conditions:

{

concept ≡ definition{

concept definition and definition ⊑ concept

18

SLIDE 19

Dom … Domain I … Interpretation

T (T)I = Dom (a class which ANY legal instance is a member of: owl:Thing) ┴ (┴)I = {}

• C

(C)I = Dom\CI C ⊓ D (C ⊓ D)I = CI  DI C ⊔ D (C ⊔ D)I = CI  DI R.C (R.C)I = { x | (x,y)  RI  y  CI } R.C (R.C)I = { x | (x,y)  RI  y  CI } nR.C (nR.C)I = { x | |{ y | (x,y)  RI  y  CI }|  n } nR.C (nR.C)I ={ x | |{ y | (x,y)  RI  y  CI }|  n } ( ) { | |{ y | ( y) y }| } =nR.C (=nR.C)I ={ x | |{ y | (x,y)  RI  y  CI }| = n } nR (nR)I = { x | |{ y | (x,y)  RI }|  n } nR (nR)I ={ x | |{ y | (x y)  RI }|  n } nR (nR) { x | |{ y | (x,y)  R }|  n } =nR (=nR)I ={ x | |{ y | (x,y)  RI }| = n }

19

SLIDE 20

in OWL in OWL

20

SLIDE 21

OWL ll t i b t

 OWL allows greater expressiveness, but  OWL (DL/Lite) puts certain constraints on the use of

RDF

• For instance: a class may not act as an instance of another

(meta)class (the same holds for properties)

 OWL has got it’s own Class identifier

<rdfs:Class rdf:ID="River"> <rdfs:subClassOf rdf:resource="#Stream"/> <owl:Class rdf:ID="River"> <rdfs:subClassOf rdf:resource="#Stream"/>

RDFS OWL

21

</rdfs:Class> </owl:Class>

SLIDE 22

What can you express in RDF/RDFS? What can you express in RDF/RDFS? Not too much…

Employee Person

• rdfs:subClassOf

… class hierarchy, necessary conditions (also equivalence is expressible because A B and B A  A ≡ B)

Employee Person

• rdf t pe

class membership

Employee(axel)

• rdf:type

… class membership … OWL provides more expressive constructs to express the DL features!

22

SLIDE 23



Instances of the Union of two Classes are either the instance of one

• r both classes

Person ≡ Man Woman

<owl:Class rdf:ID=“Person"> <owl:unionOf rdf:parseType="Collection"> <o l Class df abo t "#Woman" /> <owl:Class rdf:about="#Woman" /> <owl:Class rdf:about="#Man" /> </owl:unionOf> </owl:Class>

23

SLIDE 24



Instances of the Intersection of two Classes are simultaneously instances of both class

Man ≡ Person Male

<owl:Class rdf:ID=“Man"> <owl:intersectionOf rdf:parseType="Collection"> < l Cl df b t "#P " /> <owl:Class rdf:about="#Person" /> <owl:Class rdf:about="#Male" /> </owl:intersectionOf> </owl:Class>

24

SLIDE 25

f f

 Specify a class via a direct enumeration of its

members:

WineColor ≡ {White, Rose, Red}

<owl:Class rdf:ID="WineColor"> <rdfs:subClassOf rdf:resource="#WineDescriptor"/> <owl:oneOf rdf:parseType="Collection"> <owl:Thing rdf:about="#White"/> <owl:Thing rdf:about="#Rose"/> <owl:Thing rdf:about="#Red"/> </owl:oneOf> </owl:Class>

25

SLIDE 26

 Necessary condition ( ) via

rdfs:subclass

 Necessary and sufficient (≡) either by

⊑ + , i.e. 2 subclass definitions or:

• wl:equivalentClass

26

SLIDE 27

f l b bl

 Defining a Class by restricting its possible instances

via their property values

 OWL distinguishes between the following two:  OWL distinguishes between the following two:

• Value constraint

▪ (Mother ≡Woman hasChild.Person) ( )

• Cardinality constraint

▪ (MotherWithManyChildren ≡ Mother ≥3hasChild)

P t t i ti l l

 Property restrictions are local

• remember RDFS allows only global properties

27

SLIDE 28



A Mother is a Woman that has a child (some Person) ( ) Mother Woman hasChild.Person

<owl:Class rdf:ID=“Mother"> <rdfs:subClassOf rdf:resource="#Woman" /> <rdfs:subClassOf> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasChild" /> <owl:someValuesFrom rdf:resource="#Person" /> </owl:Restriction> </rdfs:subClassOf> </rdfs:subClassOf> </owl:Class>

28

SLIDE 29



to express the set of parents that only have female children (daughters) p p y ( g ) you would write: ParentsWithOnlyDaughters Person hasChild.Woman

<owl:Class rdf:ID="ParentsWithOnlyDaughters"> <rdfs:subClassOf rdf:resource="#Person" /> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasChild" /> <owl:onProperty rdf:resource= #hasChild /> <owl:allValuesFrom rdf:resource="#Woman" /> </owl:Restriction> </rdfs:subClassOf> ... </owl:Class> </owl:Class>

29

SLIDE 30



hasValue allows to define classes based on the existence of particular



hasValue allows to define classes based on the existence of particular property values, their must be at least one matching property value



The set of all childs of the woman MARY would be expressed like following:

<owl:Class rdf:ID=“MarysChildren">

MarysChildren Person П hasParent.{MARY}

y <rdfs:subClassOf rdf:resource="#Person" /> <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasParent" /> <owl:onProperty rdf:resource #hasParent /> <owl:hasValue rdf:resource="#MARRY" /> </owl:Restriction> </rdfs:subClassOf> </rdfs:subClassOf>

30

</rdfs:subClassOf> ... </owl:Class>

SLIDE 31



Definition of cardinality: the number of occurrences either maximum



Definition of cardinality: the number of occurrences, either maximum (maxCardinality) or minimum (minCardinality) or exact (cardinality) based upon the context (class) in which it is used



To define a half‐orphan you would write the following: p y g

<owl:Class rdf:ID=“HalfOrphan">

HalfOrphan Person П =1hasParent.Person

<owl:Class rdf:ID=“HalfOrphan">

<rdfs:subClassOf rdf:resource="#Person" />

<rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasParent"/> <owl:onProperty rdf:resource= #hasParent /> <owl:cardinality rdf:datatype="&xsd;NonNegativeInteger">1</owl:cardinality> </owl:Restriction> </rdfs:subClassOf> </rdfs:subClassOf>

31

</rdfs:subClassOf> … </owl:Class>

SLIDE 32

rdfs:Class

In summary: define a class using LOCAL

• wl:Class

restrictions on a specific Property

• wl:Restriction
• Properties:
• Properties:

 allValuesFrom: rdfs:Class (lite/DL owl:Class)  hasValue: specific Individual

l df l l l l

 someValuesFrom: rdfs:Class (lite/DL owl:Class)  cardinality: xsd:nonNegativeInteger (in lite {0,1})  minCardinality: xsd:nonNegativeInteger (in lite {0,1})

32

 maxCardinality: xsd:nonNegativeInteger (in lite {0,1})

SLIDE 33

in OWL in OWL

33

SLIDE 34

RDF Schema pro ides a co ple of pre defined

 RDF Schema provides a couple of pre defined

properties:

• rdfs:range used to indicate the range of values for a property.

i d i i h l

• rdfs:domain used to associate a property with a class.
• rdfs:subPropertyOf used to specialize a property.

OWL pro ides additional popert classes hich

 OWL provides additional poperty classes, which

allow reasoning and inference, i.e.

• owl:functionalProperty
• owl:transitiveProperty
• owl:symetricProperty

34

SLIDE 35

OWL (DL d Li ) di i i h b d

 OWL (DL and Lite) distinguishes between data type

ptoperties and object properties (RDFS does not)

Resource ObjectProperty Resource

An ObjectProperty relates one Resource to another Resource:

Resource Resource

A DatatypeProperty relates a Resource to a Literal or an XML Schema data type:

DatatypeProperty Resource Value

35

SLIDE 36

h l h l

 Philosophical reasons:

• Datatypes structured by built‐in predicates
• Not appropriate to form new datatypes using ontology language

Not appropriate to form new datatypes using ontology language

 Practical reasons:

• Ontology language remains simple and compact
• Semantic integrity of ontology language not compromised
• Implementability not compromised — can use hybrid reasoner

36

SLIDE 37

f i t f XSD d tt

 for instance, usage of XSD dattypes:

<owl:DatatypeProperty rdf:ID="yearValue"> df d i df "#Vi t Y " / <rdfs:domain rdf:resource="#VintageYear" /> <rdfs:range rdf:resource="&xsd;positiveInteger"/> </owl:DatatypeProperty>

… object properties in OWL allow for some more sophisticated definitions than only domain and p y range, see following slides…

37

SLIDE 38

l f f d

 Example: If person A is a ancestor of person B and B

• f C then A is also an ancestor of C.

ancestor+  ancestor

<owl:ObjectProperty rdf:ID=“ancestor"> <rdf:type rdf:resource="&owl;TransitiveProperty" /> <rdfs:domain rdf:resource="#Person" /> <rdfs:range rdf:resource="#Person" /> </owl:ObjectProperty>

38

</owl:ObjectProperty>

SLIDE 39

l f k h h h l

 Example: If Mary is akin to John then John is also

akin to Mary

akin‐  akin and akin  akin‐

<owl:ObjectProperty rdf:ID=“akin"> <rdf:type rdf:resource="&owl;SymmetricProperty" /> rdf:type rdf:resource &owl;SymmetricProperty / <rdfs:domain rdf:resource="#Person" /> <rdfs:range rdf:resource="#Person" /> </owl:ObjectProperty>

39

SLIDE 40

l f h ld f h h h h

 Example: If Mary is a child of John then John is the

Father of Mary

hasChild  hasParent‐ hasChild  hasParent

<owl:ObjectProperty rdf:ID=“hasChild"> <owl:inverseOf rdf:resource="hasParent" /> </owl:ObjectProperty>

40

SLIDE 41

A f nctional propert states that the al e of range

 A functional property states that the value of range

for a certain object in the domain is always the same: E l A hild h l th F th

 Example: A child has always the same Father

(biological)

Person  1hasFather

<owl:ObjectProperty rdf:ID=“hasFather"> <rdf:type rdf:resource="&owl;FunctionalProperty"/>

41

</owl:ObjectProperty>

SLIDE 42

 The symmetric and transitive property may

• nly used for connecting two resources:

rdf:Property

• wl:ObjectProperty
• wl:DatatypeProperty
• wl:FunctionalProperty
• wl:InverseFunctionalProperty
• wl:SymmetricProperty
• wl:TransitiveProperty

42

• wl:SymmetricProperty
• wl:TransitiveProperty

SLIDE 43

Description Logic First Order Logic

43

SLIDE 44

44

Social Security Number

SLIDE 45

d

 Revisited:

• How we already have learned to express ontologies

 Web Ontology Language ‐OWL:

• extending expressivity

extending expressivity

 Reasoning with OWL:

• using the extended expressivity

45

SLIDE 46

Th t d l t i b f l d ti



The presented examples contain a number of classes and properties intended to illustrate particular aspects of reasoning in OWL.



We can make inferences about relationships between classes, in particular subsumption between classes particular subsumption between classes



Recall that A subsumes B when it is the case that any instance of B must necessarily be an instance of A.

A B

46

SLIDE 47

W ≡ P F l



Woman ≡ Person ⊓ Female



Man ≡ Person ⊓ Woman



Mother ≡Woman ⊓ hasChild.Person



Father ≡ Man ⊓ hasChild Person



Father ≡ Man ⊓ hasChild.Person



Parent ≡ Father Mother



Grandmother ≡ Mother ⊓ hasChild.Parent We can further infer (though not explicitly stated):  Grandmother Person Grandmother Man Woman etc.

47

SLIDE 48

48

SLIDE 49

49

SLIDE 50

f

 You may define Classes were no individual

can fulfill its definition. Via reasoning engines h d f b f d l b such a definition can be found also in big

• ntologies.

50

SLIDE 51

 Cow ≡ Animal ⊓Vegetarian  Sheep

Animal

 Vegetarian ≡ eats  Animal  MadCow ≡ Cow ⊓ eats.Sheep

51

SLIDE 52

52

SLIDE 53

53

SLIDE 54

Open world assumption

• Open world assumption
• No unique name assumption

54

SLIDE 55



In Database Systems usually the closed world assumption is made: “The fact in



In Database Systems, usually the closed world assumption is made: The fact in the databases describe completely what I know, all that is not in the database is assumed to be false”.



This assumption is usually not valid in an open context such as the web!

Example: resource1 says: “There is a train at 14:00” “There is a train at 15:00” My query: “Is there a train at 17:00?” CWA answer: No! OWA answer: unknown! (i.e. there could be another resource2 which has info on another train at 17:00!) h f l h h f ll l Reasoning in OWL is OWL! Assume we have an RDF file with the following triples: T1 rdf:typeTrain . T2 rdf:typeTrain . T1 departureTime “14:00” . d T2 departureTime “15:00” .  Train ⊓ departureTime.{“17:00”} is not inconsistent by OWA!!!

55

SLIDE 56



What does it mean? E g A Child has two parents but Marry hasParents



What does it mean? E.g. A Child has two parents, but Marry hasParents {John Doe, Lissa Doe, Lissa Minelly}??

Some facts: family:Marry rdf:type family:person. family:Marry ex:hasParent family:JohnDoe. family:Marry ex:hasParent family:LissaDoe. family:Marry ex:hasParent family:LissaMinelly. Some cardinality axiom (in DL): family:person 2 hasParent.T There is no unique name assumption, this means that JohnDoe, LissaDoe and LissaMinelly are not necessarily different objects. Three possible options which can be “inferred” from the above example:: family:LissaDoe = family:LissaMinelly family:JohnDoe = family:LissaMinelly family:JohnDoe = family:LissaDoe Only the first is intuitive. If we add facts and axioms stating that JohnDoe is male, LissaMinelly is female, LissaDoe is female and female are disjoint from male then only the first intuitive solution remains.

56

SLIDE 57

T li itl t t th t i di id l diff t

 To explicitly state that individuals are different:

• owl:differentFrom

(between 2 individuals)

• owl:allDifferent
• wl:allDifferent

(between a set of individuals)

 To explicitly state that two individuals are identical

• owl:sameIndividualAs / owl:sameAS

 To explicitly state that two classes are identical

• owl:equivalentClass

 To explicitly state that two properties are identical

To explicitly state that two properties are identical

• owl:equivalentProperty

57

SLIDE 58



Symmetric: if P(x y) then P(y x)



Symmetric: if P(x, y) then P(y, x)



Transitive: if P(x,y) and P(y,z) then P(x, z)



Functional: if P(x,y) and P(x,z) then y=z



InverseOf: if P1(x,y) then P2(y,x)



InverseFunctional: if P(y,x) and P(z,x) then y=z



allValuesFrom: P(x y) and y=allValuesFrom(C)



allValuesFrom: P(x,y) and y=allValuesFrom(C)



someValuesFrom: P(x,y) and y=someValuesFrom(C)



hasValue: P(x,y) and y=hasValue(v)



cardinality: cardinality(P) = N



minCardinality: minCardinality(P) = N



maxCardinality: maxCardinality(P) = N



maxCardinality: maxCardinality(P) = N



equivalentProperty: P1 = P2



intersectionOf: C = intersectionOf(C1, C2, …)



unionOf: C = unionOf(C1, C2, …)



complementOf: C = complementOf(C1)



• neOf: C = one of(v1 v2 )



• neOf: C = one of(v1, v2, …)



equivalentClass: C1 = C2



disjointWith: C1 != C2



sameIndividualAs: I1 = I2



differentFrom: I1 != I2



AllDifferent: I1 != I2 I1 != I3 I2 != I3 Legend:

Properties are indicated by: P, P1, P2, etc Specific classes are indicated by: x, y, z Generic classes are indicated by: C C1 C2



AllDifferent: I1 != I2, I1 != I3, I2 != I3, …



Thing: I1, I2, …

58

Generic classes are indicated by: C, C1, C2 Values are indicated by: v, v1, v2 Instance documents are indicated by: I1, I2, I3, etc. A number is indicated by: N P(x,y) is read as: “property P relates x to y”

SLIDE 59

 OWL Lite F ll

• (sub)classes, individuals
• (sub)properties, domain, range
• intersection
• (in)equality

RDF Schema

Full DL

(in)equality

• cardinality 0/1
• datatypes
• inverse, transitive, symmetric

h l

Lite

• hasValue
• someValuesFrom
• allValuesFrom

 OWL Full  OWL DL  OWL Full

• Allow meta‐classes etc

 OWL DL

• Negation (disjointWith, complementOf)
• unionOf
• Full Cardinality

59

Full Cardinality

• Enumerated types (oneOf)

SLIDE 60

...

60

SLIDE 61

 Since OWL makes an open world assumption it is possible to  Since OWL makes an open world assumption: it is possible to

extend/import classes from other ontologies

 Consequences of additional propositions are monotonic

• New information can not retract existing (but may be contradictory,

i.e. cause inconsistency)

 owl:imports imports another ontology in the sense that it  owl:imports imports another ontology in the sense that it

becomes part of the ontology doing the import

 owl:imports is transitive

• (if A imports B and B imports C, A import B and C)

 Note: Import is different to just declare a namespace and

reference to i e a concept since this does not imply to import reference to i.e. a concept, since this does not imply to import associated constraints

61

SLIDE 62

l i I f id i l d i

 owl:versionInfo provides a construct to include version

information but has no impact on model theory

 owl:priorVersion owl:backwardCompatibleWith and  owl:priorVersion, owl:backwardCompatibleWith and

• wl:incompatibleWith can be used to track changes and

reference other ontologies

 owl:DeprecatedClass and owl:DeprecatedProperty allow

versioning on a high level of granularity

62

SLIDE 63

f

• default values
• closed world option

h

• arithmetic
• string operations

l d l h

• involved axioms on axiom values, such as

functional dependencies l

• partial imports
• view definitions (it is not a query language)

d l h

• procedural attachment

63

SLIDE 64

d h d

 Compared with RDF/RDFS, OWL provides a more

formal language which allows expressing more axioms but also adds some restrictions axioms, but also adds some restrictions

 We can do inferences such as classify instances,

detect inconsistencies etc detect inconsistencies, etc.

 Last version Feb. 2004, but still under progress  http://www.w3.org/2004/OWL/

64

SLIDE 65

W3C Documents

 W3C Documents

• Guide: http://www.w3.org/TR/owl‐guide/
• Reference: http://www.w3.org/TR/owl‐ref/
• Semantics and Abstract Syntax:

http://www.w3.org/TR/owl‐semantics/

 OWL Tutorials

• Ian Horrocks, Sean Bechhofer:

http://www.cs.man.ac.uk/~horrocks/Slides/Innsbruck‐ tutorial/

• Roger L. Costello, David B. Jacobs:

http://www.xfront.com/owl/

 Example Ontologies, e.g. here:

• http://www.daml.org/ontologies/

65

SLIDE 66

Time for ...

66