Transcript DAML + OIL an ontology language for the Semantic Web Peter Aronsson (pelab) Cécile Åberg (iislab)

DAML + OIL
an ontology language for the
Semantic Web
Peter Aronsson (pelab)
Cécile Åberg (iislab)
Outline
•
•
•
•
•
•
•
•
•
Ontology Language requirements
Ontology example
XML/RDFS are not enough
DAML+OIL: generalities
DAML+OIL: syntax
DAML+OIL: reasoning
DAML+OIL: some discussion
DAML+OIL: summary
OilEd: demo
Ontology language requirement
• UEP: Universal expressive power
• SyI: Support for Syntactic Interoperability:
easy to read the data (parsers)
easy to get a representation usable by applications
(query-able)
• SeI: Support for Semantic Interoperability
capable of understanding the data
Ontology example (OIL)
class-def animal
%plants are a class that is disjoint from animals
class-def plant subclass-of NOT animal
%it is necessary but not sufficient for a tree to be a plant:
class-def tree subclass-of plant
%branches are PART OF trees
class-def branch
slot-constraint is-part-of has-value tree
%it is necessary and sufficient for a carnivore to be an animal:
class-def defined carnivore subclass-of animal
slot-constraints eats value-type animal
%herbivores eat only plants OR part of plants
class-def defined herbivore subclass-of animal
slot-constraint eats value-type plant OR
(slot-constraint is-part-of has-value plant)
XML is not enough
<class-def>
<name>branch</name>
<slot-constraint>
<name>is-part-of</name>
<has-value>tree</has-value>
</slot-constraint>
</class-def>
+ UEP: anything can be encoded in XML
(if a grammar can be defined for it)
+ SyI: exists reusable XML parsers
– SeI: Do not impose a common interpretation of the
data:  only feasible for closed collaboration
RDF/RDFS is not enough (1/2)
+ UEP: Can express hierarchies of objects, i.e.
ontologies
+ SyI: Exists reusable RDF/RDFS parsers
/ SeI:
+ has a specific semantic for some terms (subClassOf)
– there is no semantic preserving mappings between all objects
RDFS can be extended to define a more
powerful ontology language that allows
inference
RDF/RDFS is not enough (2/2)
oil:OR
rdfs:Class
oil:AND
oil:classExpression
rdfs:type
rdfs:subClassOf
oil:hasClass
rdfs:type
carnivore
rdfs:type
herbivore oil-subclass-of
oil:AND
rdfs:type
oil:hasClass
rdfs:type
oil:hasClass
animal
class-def defined herbibore
sublclass-of animal, NOT carnivore
rdfs:Class
3 steps to extend RDFS
Type of expression
Modeling primitives of
1
ontology language L.
2
3
Express specific
ontology in L.
Produce instances of
the specific ontology
Example
Encoded in
oil:subclass-of
oil:not
RDF: meta ontology
coded in RDFS
class-def giraffe
subclass-of animal
slot-constraints
eats
value-type leaf
RDF: ontology coded
in meta ontology +
RDFS
animal12
-eats leaf34
RDF: metaontology +
RDFS + ontology
DAML + OIL
• Syntax = extension of RDFS
–
–
–
–
–
constraints on properties: exists, forall, cardinality
boolean combination of classes and restrictions
equivalence, disjointnes, covering
necessary and sufficient condition
constraints on properties
• 2 well defined semantic specification
– model theoretic: description logic
– axiomatization in KIF: predicate logic
 Allows for machine understanding and
automated reasoning.
Why automated reasoning?
• Ontology design:
– check class consistency and unexpected implied relationships
– especially needed for large, multi-authored ontologies
• Ontology integration/sharing
– assert inter-ontology relationships
– reasoner computes integrated class hierarchy
• Ontology deployment
– check if facts are consistent wrt ontology
– check if individuals are instance of ontology classes
The semantic web needs a logic on top
(Henry Thompson)
DAML+OIL: short history
Before: Ontologies, ML for Web, DL, Frame Lang., etc.
In ‘00: first OIL related publications (EU researchers)
Aug00: kickoff meeting for DAML US project
Oct00: DAML-ONT: no inference rules
 DAML team looks for inference mechanisms
 Experiments with predicate logic
 OIL, EU project based on DL
Dec00: DAML + OIL: 2 semantics.
 Most of OIL is kept except its RDF syntax.
WebOnt WG
- language features
(OWL req.)
- testing/implement.
- semantics
- guidelines
Nov 01: WebOnt (W3C) working group kick off
Feb 28: WebOnt publishes OWL requirements
DAML+OIL: participants
OntoWeb
OIL
E-business emphasis
Semantic Web
Resources EU
DAML +
EU W3C
DAML +
OIL for
OIL
WebOnt
Semantic Web
Activity
RDF-S
RDF
WebOnt WG
W3C
DAML
Military
emphasis
DAML
Comparing OIL and DAML-ONT (1/2)
OIL-Standard
Semantics
Meaning of a collection
of statements
Capabilities
Built in Classes
Primitive Classes
Defined Classes
Class Hierarchy
Property Hierarchy
Equivalence
Disjoint, Disjoint Cover
Inverse/Transitive Prop
Union/Intersection
Complement
Domain Restriction
DAML-ONT
denotational
English
complete, unambiguous partial, ambiguous
always conjunctive
usually conjuctive
sometimes disjunctive
(domain from RDF)
thing, nothing
yes
yes
yes
yes
yes (defined classes)
yes
yes
yes, class constructor
yes, class constructor
yes, conjunctive
thing, nothing
yes
maybe, ugly
yes, from RDF
yes
maybe
yes
yes
yes, class definition
yes, class definition
yes, disjunctive (from RDF)
Comparing OIL and DAML-ONT (2/2)
Range Restrictions
Filler Restrictions
Cardinality Restrictions
Sets
Lists
Defaults
Individuals
Concrete Types (int, ...)
Reasoning
Specification
Completion Possible
Least Partial Model
Difficulty
OIL-Standard
DAML-ONT
global and local
local (and global)
local (and global)
yes
no
no
yes
yes
global (from RDF)
and local
local (and global)
global only
yes
yes
yes
yes
yes
complete
no
no
EXPtime complete (?)
incomplete
no
no
unknown, at least NP hard
DAML+OIL: unusual DL features
– non frame syntax
 must use a specific editor
– organizational information lost (see e.g. later):
list of axioms:
no sense of a main definition of a class or individual
+ large collection of primitive types (int…)
/ allows individual to occurs in concept definition
 reasoners are difficult to construct
DAML+OIL syntax
DAML+OIL: DL expressivity
– Basic DL: ALC = {and, or, not}
– Other DL = ALC + set of roles
– OIL: SHIQ
• very expressive:
ALC + {transitive roles + cardinality restriction max1
on roles + is-a on roles + inverse roles + cardinality
restriction (e.g. 2<)}
• note: no reasoning on individuals.
– DAML+OIL: DL name not specified in lit.
• SHIQ + some: cf. list of axioms and operators
• OilEd: FaCT classifier (SHIQ)
DL classifier + modal logic satisfiability tester
DAML+OIL: what you can reason about
•
(DAML+OIL medical terminology ontology)
transitive roles capture patronomy, causality, etc.
R(a,b) and R(b,c)  R(a, c)
Cause(smoking, cancer) and Cause(cancer, death)  Cause(smoking, death)
Smoking  causes.Cancer plus Cancer  causes.Death
 Smoking  causes.Death
•
multiple equality/inclusion axioms generate new axioms
StomachUlcer = Ulcer  hasLocation.Stomach
plus StomachUlcer  hasLocation.LiningOfStomach
 Ulcer  hasLocation.Stomach  OrganLiningLesion
Axiom1) stomach ulcer is an ulcer and is an object located in the stomach
Axiom2) stomach ulcer is-an object that is located in the lining of stomach
inference) an object that is an ulcer and is an object located in the stomach
is-an object that is located in the lining of stomach
DAML+OIL: what you can reason about
•
inverse roles capture, e.g., causes/causedBy relationship.
“if (A linked to B by R) is-a C then (B is linked to C by the inverse of R)”
E.g.: causes is inverse of causedBy
if death caused by smoking is a premature death then smoking causes premature death
Death and causedBy.Smoking  prematureDeath
 Smoking  causes.PrematureDeath
•
cardinality restrictions add consistency constraints
E.g.: If blood pressure can have a value that can be either high or low and can have
only one value, then a blood pressure can not be high and low at the same time.
BloodPressure 
hasValue.(high  low)   1hasValue plus High   low
 HighLowBloodPressure  
DAML+OIL: what you can not reason about
• No property construct
e.g.: parent o brother  uncle, ancestor = parent+
• No variable
Ulcer  haslocation.?r  haslocation.(LiningOf.?x)
• Only unary and binary predicates
can not express directly P(x, y, z)
Language extensions are possible but have a cost
 tractability vs. expressivity problem
DAML+OIL and OWL requirements
(1/2)
+
+
/
/
+
+
/
+ = yes, / = partial
R1 shared (daml:ontology, ns, classes)
R2 extension (daml:import)
R3 evolution (daml:versionInfo)
R4 interoperability
(rdfs:subClassOf/subPropertyOf,...)
R5 inconsistency detection (DL reasoner)
R6 scalability
R7 ease of use (+ classes, frame (DL), - RDF)
DAML+OIL and OWL requirements
(2/2)
+
+
•
/
R10 XML syntax
R12 ontology based search (can be done)
R14 expressiveness (limited to the chosen DL)
R18 explainability (inferences rules available)
no consensus:
R8 data persistence, R9 security, R13 querying, R15 proof
checking, R16 Trust, R17 Tagging
other requirements (from other groups):
R19: default info, R20: part whole info R10 XML syntax
Problem:
Sharing (exchanging) ontologies
• Consistent interpretation
– requires syntactic and semantic understanding
• the intention of the author is clear for the
agent using the ontology
– requires semiotic understanding
• DAML+OIL venture looses the original
OIL semiotic support provided by frame
languages:
grouping axioms specific to a class
Class-def
defined White-van-man
subclass-of Man
slot-constraint drives
has-values White-van
covered White-van-man by
Aggressive-driver
Class-def
primitive White-van-man
equivalent
White-van-man
(Man and
slot-constraint drives
has-values White-van))
covered White-van-man by
Aggressive-driver
<rdfs:Class rdf:ID=“White-van-man”>
<rdfs:subClassOf>
<rdfs:Class
rdf:about=“Aggressive-driver”/>
</rdfs:subClassOf>
</rdfs:Class>
<rdfs:Class
rdf:about=“White-wan-man”>
<daml:sameClassAs>
<rdfs:Class>
<daml:intersectionOf>
<rdfs:Class rdf:about=“man”/>
<daml:Restriction>
<daml:onProperty
rdf:resource=“drives”/>
<daml:hasClass
rdf:resources=“White-van”/>
</daml:Restriction>
</daml:intersectionOf>
</rdfs:Class></...></rdfs:Class>
Extending DAML + OIL
• Work in progress on datatypes
– supporting some of XMLS datatypes
– making datatypes disjoint from abstract classes and
only accessible via properties
– maintains decidability and tractability of language
• Further implementation in upper layers
– DAML-RULES, DAML-S
– upper layers use DAML+OIL as DAML uses RDFS
DAML+OIL status
•
•
•
•
annotated walkthrough
examples
full syntactic definition (RDFS)
denotational and axiomatic semantic published
– 1st formal semantics for a web language
• Proposal to W3C for standardization ongoing
(WebOnt)
• Daml ontology library: 140+ ontologies
• Web tools: annotation, API, browser, editor,
validator, inference engine, ontology editor, query,
etc.
DAML+OIL Summary
• Ontology Language for the Semantic Web
• Extends RDFS
– more expressive power
– well defined semantics
– 100% mapping in XML
• Implementable
– decidable and tractable reasoning
– cost = restriction on the expressivity
• Extensible: loosing some decidability and/or tractability
• Usage: DAML library of ontologies + web services
OilEd Demo