OOPS!: on-line ontology diagnosis by Maria Poveda

OOPS! (ONTOLOGY PITFALL SCANNER!):
ON-LINE ONTOLOGY DIAGNOSIS
María Poveda-Villalón
Asunción Gómez-Pérez and Mari Carmen Suárez-Figueroa
Ontology Engineering Group.
Universidad Politécnica de Madrid.
mpoveda@fi.upm.es
Data Quality Tutorial – SEMANTICS 2016
12th September
This work has been partially supportedby the Spanish project"4V:volumen, velocidad, variedad y validez en
la gestión innovadorade datos” (TIN2013-46238-C4-2-R) and theEuropeanproject “Ready4SmartCities - ICT
Roadmap and Data Interoperability for Energy Systems in Smart Cities” (FP7-608711).
OOPS! website: http://oops.linkeddata.es
Twitter account: @OOPSoeg

OOPS!: on-line ontology diagnosis
License
• This work is licensed under the Creative Commons
Attribution – Non Commercial – Share Alike License
• You are free:
• to Share — to copy, distribute and transmit the work
• to Remix — to adapt the work
• Under the following conditions
• Attribution — You must attribute the work by inserting
• “[source http://www.oeg-upm.net/]” at the footer of each reused
slide
• a credits slide stating: “OOPS! (OntOlogy Pitfall Scanner!): on-
line ontology diagnosis” by María Poveda-Villalón, Mari Carmen
Suárez-Figueroa and Asunción Gómez-Pérez ”
• Non-commercial
• Share-Alike
2

Ontology engineering and ontology evaluation
• The correct application of methodologies benefits the ontology quality
• No complete guaranty
3
Ontology evaluation (checking the technical quality
of an ontology against a frame of reference) is a
crucial activity in ontology engineering projects
Ontology diagnosis: identifying parts
of the ontology directly responsible for
incorrectness and incompleteness
1996 1997 ... 2001 2002 2003 20041995 2005 2006 ... 2009 2010
Guide 101 XD
EXtreme
Ontology
RapidOWL
Grüninger
& Fox
On-To-
Knowledge
METHON
TOLOGY
DILIGENT NeOn
O. Development Methodologies Ontology Development Lightweight Approaches

Introduction
4
Ontology Evaluation
Conceptual
Practical
Top level frameworks and definitions
Guidelines and methods
Tools

Tools
Introduction
5
Ontology Evaluation
Conceptual
Practical
• Upper-level ontology engineers
• Deep knowledge in formal logic
and philosophy

Introduction
6
Ontology Evaluation
• Ontology engineers
• Knowledge in
ontological engineering
Conceptual
Practical
Tools
and philosophy

Introduction
7
Ontology Evaluation
• Ontology engineers
• Knowledge in
ontological engineering
Conceptual
Practical
and philosophy
Tools
• Ontology developers
• Domain experts
Target audience

Table of Contents
• Introduction
• Approach
• Pitfall catalogue
• OOPS!
• Future lines of work
8

Iterative process
9
14 piftalls
Manual inspection
Classiﬁcation:
Ontology Design
Patterns
2009
OOPS!PitfalloriginCatalogue
1st
Compilation
Phase

Manual inspection
Literature review
24 piftalls
Classiﬁcation:
aspects and errors
in hierarchies
20102nd
14 piftalls
Manual inspection
Classiﬁcation:
Ontology Design
Patterns
2009
1st
ExtensionCompilation
Phase
Iterative process
10

Manual inspection
Literature review
24 piftalls
Classification:
aspects and errors
in hierarchies
20102nd
14 piftalls
Manual inspection
Classification:
Ontology Design
Patterns
2009
1st
Manual inspection
Literature review
Web User Interface
29 piftalls
Classification:
dimensions in tools
2012
21 pitfalls detected
3rd
ExtensionCompilation Implementation
Phase
Iterative process
11

Manual inspection
Literature review
24 piftalls
Classification:
aspects and errors
in hierarchies
20102nd
14 piftalls
Manual inspection
Classification:
Ontology Design
Patterns
2009
1st
Manual inspection
Literature review
Web User Interface
29 piftalls
Classification:
dimensions in tools
2012
3rd
Manual inspection
Literature review
Collaborations
Web User Interface
Web Service
40 piftalls
Classification:
aspects and
importance levels
2014
ExtensionCompilation Implementation Linked Data ext.
4th
Phase
Iterative process
12

Manual inspection
Literature review
Collaborations
Web User Interface
Web Service
41 piftalls
Classification:
aspects and
importance levels
2015
Quality model
Repair suggestions
5th
Manual inspection
Literature review
24 piftalls
Classification:
aspects and errors
in hierarchies
20102nd
14 piftalls
Manual inspection
Classification:
Ontology Design
Patterns
2009
1st
Manual inspection
Literature review
Web User Interface
29 piftalls
Classification:
dimensions in tools
2012
3rd
Manual inspection
Literature review
Collaborations
Web User Interface
Web Service
40 piftalls
Classification:
aspects and
importance levels
2014
RefinementExtensionCompilation Implementation Linked Data ext.
4th
Phase
Iterative process
13

Table of Contents
• Introduction
• Approach
• OOPS!
14

Disclaimer
• Pitfalls could represent errors
• Pitfalls could lead to errors
• Pitfalls are not always errors depending on:
o modelling decisions taken by the team of developers
o ontology requirements previously set
o application context of the ontology
o the domain of the ontology
15

List of 41 pitfalls
16
P01. Creating polysemous elements
P02. Creating synonyms as classes
P03. Creating the relationship “is” instead ofusing
“rdfs:subClassOf”, “rdf:type” or “owl:sameAs”
P04. Creating unconnected ontology elements
P05. Defining wrong inverse relationships
P06. Including cycles in a class hierarchy
P07. Merging differentconcepts in the same class
P08. Missing annotations
P09. Missing domain information
P10. Missing disjointness
P11. Missing domain or range in properties
P12. Equivalentproperties notexplicitly declared
P13. Inverse relationships notexplicitly declared
P14. Misusing “owl:allValuesFrom”
P15. Using “some not” in place of “not some”
P16. Using a primitive class in place of a defined one
P17. Overspecializing a hierarchy
P18. Overspecializing the domain or range
P19. Defining multiple domains or ranges in properties
P20. Misusing ontology annotations
P21. Using a miscellaneous class
P22. Using differentnaming conventions in the ontology
P23. Duplicating a datatype already provided by the
implementation language
P24. Using recursive definitions
P25. Defining a relationship as inverse to itself
P26. Defining inverse relationships for a symmetric one
P27. Defining wrong equivalentproperties
P28. Defining wrong symmetric relationships
P29. Defining wrong transitive relationships
P30. Equivalentclasses notexplicitly declared
P31. Defining wrong equivalentclasses
P32. Several classes with the same label
P33. Creating a property chain with just one property
P34. Untyped class
P35. Untyped property
P36. URI contains file extension
P37. Ontology not available on the Web
P38. No OWL ontology declaration
P39.Ambiguous namespace
P40. Namespace hijacking
P41. No license declared

Pitfall template
Pitfall template
17
Title Code and title of the pitfall
Importance
level
{Critical | Important | Minor}
Aspects
Ontology evaluation
aspects related to the pitfall
Affects to
{Ontology | [Classes,
Object properties, Datatype
properties]}
Description
Detailed explanation of what the pitfall consists in. This field might contain
references to other approaches.
Example
Graphical representation Natural language description
UML_Ont profile
OWL source
Natural language explanation of the
graphical example or OWL code.
How to solve it
Description of the actions to be taken by ontology engineers in order to solve the
described pitfall.
References* Pointers to related bibliographical references or links to URLs.
* optional
Process
details
Process
details

Assigning importance level
§ Survey to the Semantic Web community
§ For 35 pitfalls (from that point level assigned during description)
§ Participants were asked to mark each pitfall as:
o Critical
o Important
o Minor
o Not a problem (additional)
§ 54 answers:
o 28 experts
o 22 medium confidence
o 4 low confidence
18
According to the negative consequences of each
pitfall in the ontology

Critical (1)
P01. Creating polysemous elements
P03. Creating the relationship “is” instead of using ''rdfs:subClassOf'', ''rdf:type'' or ''owl:sameAs''
P05. Defining wrong inverse relationships
P14. Misusing ''owl:allValuesFrom''
P16. Using a primitive class in place of a defined one
P19. Defining multiple domains or ranges in properties
P27. Defining wrong equivalent properties
P28. Defining wrong symmetric relationships
P29. Defining wrong transitive relationships
P31. Defining wrong equivalent classes
P37. Ontology not available on the Web
P39. Ambiguous namespace
Important (2)
P10. Missing disjointness
P11. Missing domain or range in properties
P12. Equivalent properties not explicitly declared
P23. Duplicating a datatype already provided by the
implementation language
P24. Using recursive definitions
P25. Defining a relationship as inverse to itself
P26. Defining inverse relationships for a symmetric one
P30. Equivalent classes not explicitly declared
P34. Untyped class
P38. No OWL ontology declaration
Minor (3)
P02. Creating synonyms as classes
P04. Creating unconnected ontology elements
P07. Merging different concepts in the same class
P08. Missing annotations
P09. Missing domain information
P13. Inverse relationships not explicitly declared
P20. Misusing ontology annotations
P22. Using different naming conventions in the
ontology
P32. Several classes with the same label
P33. Creating a property chain with just one property
P36. URI contains file extension
Pitfall classification by importance level
19
Phase 2
Phase 1
survey
Phase 1
survey
Phase 2
Phase 1
survey
Phase 2

OOPS!: on-line ontology diagnosis 20
Classifying by ontology evaluation aspects
Structural
Dimension
Usability-profiling
Dimension
Functional Dimension
Ontology Understanding
Ontology Clarity
Ontology Metadata
Modeling Decisions
Requirement
Completeness
Wrong Inference
No Inference
Real World Modelling
or Common Sense
Structural
Dimension
Ontology Language
Application Context
Legend
AspectDimension Critical pitfall Important pitfall Minor pitfall * Pitfall appears twice
P27. Defining wrong equivalent properties
P31. Defining wrong equivalent classes
P01. Creating polysemous
elements *

Structural
Dimension
Usability-profiling
Dimension
Ontology Clarity
Ontology Metadata
Modeling Decisions
Requirement
Completeness
Wrong Inference
No Inference
or Common Sense
Structural
Dimension
Ontology Language
Application Context
Legend
elements *
P13. Inverse relationships not
explicitly declared
P11. Missing domain or range
in properties
P12. Equivalent properties not
explicitly declared

P13. Inverse relationships not
explicitly declared
P24. Using recursive definitions
P09. Missing domain
information *
P07. Merging different
concepts in the same
class
P02. Creating synonyms
as classes
P20. Misusing ontology
annotations
elements *
P03. Creating the relationship “is”
instead of using “rdfs:subClassOf”,
“rdf:type” or “owl:sameAs”
P11. Missing domain or range
in properties
P12. Equivalent properties not
explicitly declared
P23. Duplicating a datatype already provided
by the implementation language
P04. Creating unconnected
ontology elements
P08. Missing
annotations
P10. Missing disjointness (2)
P14. Misusing “allValuesFrom” P15. Using “some not” in place of “not some”
P16. Using a primitive class in place of a defined one
Modeling Decisions
Requirement
Completeness
Wrong Inference
No Inference
or Common Sense
Ontology Clarity
P22. Using different naming
conventions in the ontology
Structural
Dimension
Usability-profiling
Dimension
P26. Defining inverse relationships
for a symmetric one
P30. Equivalent classes not explicitly declared
P32. Several classes with
the same label
P33. Creating a property chain with just one
property
Ontology Language
P34. Untyped class
P36. URI contains file
extension
Application Context
P37. Ontology not
available on the Web *
P38. No OWL ontology
declaration *
P39. Ambiguous namespace
Ontology Metadata
elements *
P38. No OWL ontology
declaration *
P37. Ontology not available on the
Web *
Legend

Detection method template
Detection method template
23
Code Code of the method
Pitfall
cardinality
{1 |N}
Method
addresses
{Ontology | [Classes, Object
properties, Datatype properties]}
Technique
{[Structural pattern matching,
Linguistic analysis,
Specific characteristic search]}
Pitfall
affects to
{Ontology | [Classes, Object
properties, Datatype properties]}
Description
General explanation of what the method consists in based on the pitfall to be detected.
Limitations*
Corner cases or well-known exceptions where the pitfalls are not currently detected.
Patterns
Graphical representation Natural language description
UML_Ont profile
OWL source
Natural language explanation of the pattern.
External resources used*
Pointers to external libraries, systems or resources used within the method
implementation.
* optional
From
pitfall
template

Pitfalls and methods: example P25
24
Title P25. Defining a relationship as inverse to itself
Importance
level
Important
Aspects Modelling decisions Affects to Object properties
Description
A relationship is defined as inverse of itself. In this case, this relationship could have been defined as
owl:SymmetricProperty instead.
Examples
Graphical representation and/or OWL code Natural language description
<<owl:inverseOf>>
<<owl:ObjectProperty>>
hasBorderWith
The graphical example shows the object property
“hasBorderWith”, which has been defined as inverse
of itself by means of the primitive owl:inverseOf.
How to solve it
One should check whether the object property defined as inverse of itself satisfies the following condi-
tion: every time the object property holds between the individuals “a” and “b” it also holds between
“b” and “a”. If the object property does fulfil the condition, it should be defined as symmetric (using
owl:SymmetricProperty) and the owl:inverseOf statement should be deleted.
While the situation described in this pitfall will not lead to any reasoning problem and it could be
considered a workaround to avoid increasing the ontology expressivity, it is more accurate to define the
object property as symmetric (using owl:SymmetricProperty) instead of as inverse to itself.
Table 6: P25. Defining a relationship as inverse to itself
Code M1-P25. Detecting relationships inverse to themselves
Pitfall
cardinality
N Method addresses Object properties
Technique Structural pattern matching Pitfall affects to Object properties
Description
This method iterates over the list of object properties included in the ontology.
If a given object property acts at the same time as subject and object in an owl:inverseOf statement (pattern
A), then a pitfall is flagged.

P25
descriptionTitle P25. Defining a relationship as inverse to itself
Importance
level
Important
Description
Examples
<<owl:inverseOf>>
hasBorderWith
How to solve it
Pitfall
cardinality
Description
Patterns
Pattern A:
<<owl:inverseOf>>
objectPropertyS
The graphical pattern shows an object property that
has an owl:inverseOf axiom whose target object
property is the same object property.
Table 7: Detection method proposed for P25
8
25
P25. Defining a relationship as inverse to itselfTitle P25. Defining a relationship as inverse to itself
Importance
level
Important
Description
Examples
<<owl:inverseOf>>
hasBorderWith
How to solve it
Pitfall
cardinality
Description
Importanc
level
Aspects Modelling decisions Affects to
Description
A relationship is defined as inverse of itself. In this case, this relationship c
Examples
Graphical representation and/or OWL code Natural langu
<<owl:inverseOf>>
hasBorderWith
The graphical example
“hasBorderWith”, which
of itself by means of the
How to solve it
One should check whether the object property defined as inverse of itself sa
tion: every time the object property holds between the individuals “a” and
“b” and “a”. If the object property does fulfil the condition, it should be de
While the situation described in this pitfall will not lead to any reasoning
considered a workaround to avoid increasing the ontology expressivity, it is m
object property as symmetric (using owl:SymmetricProperty) instead of as inver
Table 6: P25. Defining a relationship as inverse to
Importance
level
Important
Description
Examples
<<owl:inverseOf>>
hasBorderWith
How to solve it

26
M1-P25. Detecting relationships inverse to themselvesP25
description
Pitfall
cardinality
Description
Patterns
Pattern A:
<<owl:inverseOf>>
objectPropertyS
Importance
level
Important
Description
Examples
<<owl:inverseOf>>
hasBorderWith
How to solve it
Pitfall
cardinality
Description
Patterns
Pattern A:
<<owl:inverseOf>>
objectPropertyS
8

27
Title
P19. Defining multiple domains or ranges in proper-
ties
Importance
level
Critical
Aspects Wrong inference Affects to
Object properties
Datatype properties
Description
The domain or range (or both) of a property (relationships and attributes) is defined by stating more than
one rdfs:domain or rdfs:range statements. In OWL multiple rdfs:domain or rdfs:range axioms are allowed,
but they are interpreted as conjunction, being, therefore, equivalent to the construct owl:intersectionOf.
This pitfall is related to the common error that appears when defining domains and ranges described in [2].
Examples
Event
Nation
takesPlaceIn
<<rdfs:domain>>
<<rdfs:range>>
City
<<rdfs:range>>
The graphical example shows an object property,
“takesPlacesIn”, whose domain is the class “Event”
and whose range is defined as “City” and as “Na-
tion”. As the range of the relationship is interpreted
as an intersection, whenever an individual appears as
object in such relationship, it will be classified both
as instance of “City” and “Nation”. This situation
is probably not intended by the developer, since the
intersection of “City” and “Nation” is the empty set.
How to solve it
If there is more than one rdfs:domain or rdfs:range statements defined for a given object or datatype
property, check:
For domains:
(a) For each object or datatype property with multiple domains in the ontology, we recommend answering
the following question “Does every individual in the domain of the given property necessarily belong
to each and every one of the intersected classes?”. If the answer is “no”, developers should (a) join the
classes that appear in the different domain declarations by the “or” operator (i.e., owl:unionOf) and set
this union of classes as the domain of the property and (b) remove the initial rdfs:domain declarations.
For ranges:
(a) For each object property with multiple ranges in the ontology, we recommend answering the following
question “Does every individual in the range of the given object property necessarily belong to each and
every one of the intersected classes?”. If the answer is “no”, developers should (a) join the classes that
appear in the different range declarations by the “or” operator (i.e., owl:unionOf) and set this union of
classes as the range of the property and (b) remove the initial rdfs:range declarations.
(b) For each datatype property with multiple domains in the ontology, we recommend including at most
one datatype as range. We recommend taking into account the built-in datatype hierarchy defined in
[1] to select such datatype. If there is more than one plausible candidate, find their lowest common
ancestor and set it as the range of the datatype property.
References
[1] Built-in datatype hierarchy http://www.w3.org/TR/xmlschema-2/built-in-datatypes
[2] Rector, A., Drummond, N., Horridge, M., Rogers, J., Knublauch, H., Stevens, R., Wang,
H., and Wroe, C. (2004). OWL pizzas: Practical experience of teaching OWL-DL: Common
errors & common patterns. In Engineering Knowledge in the Age of the Semantic Web,
pages 63-81. Springer.

P19
descriptionTitle
ties
Importance
level
Critical
Object properties
Datatype properties
Description
Examples
Event
Nation
takesPlaceIn
<<rdfs:domain>>
<<rdfs:range>>
City
<<rdfs:range>>
How to solve it
property, check:
For domains:
For ranges:
References
Table 3: P19. Deﬁning multiple domains or ranges in properties
5
28
Title
ties
Importance
level
Critical
Object properties
Datatype properties
Description
Examples
How to solve it
property, check:
For domains:
Title
ties
Importance
level
Critical
Object properties
Datatype properties
Description
Examples
Event
Nation
takesPlaceIn
<<rdfs:domain>>
<<rdfs:range>>
City
<<rdfs:range>>
How to solve it
property, check:
For domains:

P19
description
29
M1-P19. Detecting multiple domains or ranges in object properties
Title
ties
Importance
level
Critical
Object properties
Datatype properties
Description
Examples
Event
Nation
takesPlaceIn
<<rdfs:domain>>
<<rdfs:range>>
City
<<rdfs:range>>
How to solve it
property, check:
For domains:
For ranges:
References
5
Code M1-P19. Detecting multiple domains or ranges in object properties
Pitfall
cardinality
Technique Structural pattern matching Pitfall affects to
Object properties
Datatype properties
Description
If an object property has more than one rdfs:domain axiom (pattern A) and the classes the domain axioms
refer to do not match, then a pitfall is flagged.
If an object property has more than one rdfs:range axiom (pattern B) and the classes the range axioms
The method checks if the multiple classes declared as domain or range are the same class or equiva-
lent classes. If class restrictions apply, the method checks whether they are syntactically equivalent.
Limitations
The method does not check if two different class restrictions or anonymous classes logically represent identical
sets of individuals.
Patterns
Pattern A:
ClassA ClassB
objectPropertyS
<<rdfs:domain>> <<rdfs:domain>>
has two rdfs:domain axioms defined.
Pattern B:
ClassA ClassB
objectPropertyS
<<rdfs:range>> <<rdfs:range>>
has two rdfs:range axioms defined.
Table 1: Detection method 1 proposed for P19
M2-P19. Detecting multiple domains or ranges in datatype properties
Code M2-P19. Detecting multiple domains or ranges in datatype properties
Pitfall
cardinality
N Method addresses Datatype properties
Object properties
Datatype properties
Description
This method iterates over the list of datatype properties included in the ontology.
If a datatype property has more than one rdfs:domain axiom (pattern A) and the classes the domain
axioms refer to do not match, then a pitfall is flagged.
If a datatype property has more than one rdfs:range axiom (pattern B) and the datatypes the range
axioms refer to are not the same one, then a pitfall is flagged.
The method checks if the multiple classes declared as domain are the same class or equivalent classes. If
class restrictions apply, the method checks whether they are syntactically equivalent.
Limitations
Patterns
Pattern A:
ClassA ClassB
<<owl:DatatypeProperty>>
datatypePropertyS
<<rdfs:domain>><<rdfs:domain>>
The graphical pattern shows a datatype property
that has two rdfs:domain axioms defined.
Pattern B:
<<primitive>>
xsd:datatype1
datatypePropertyS
<<primitive>>
xsd:datatype2 The graphical pattern shows a datatype property
that has two rdfs:range axioms defined.

M1-P19
M2-P19
Code M1-P19. Detecting multiple domains or ranges in object properties
Pitfall
cardinality
Object properties
Datatype properties
Description
If an object property has more than one rdfs:domain axiom (pattern A) and the classes the domain axioms
If an object property has more than one rdfs:range axiom (pattern B) and the classes the range axioms
The method checks if the multiple classes declared as domain or range are the same class or equiva-
lent classes. If class restrictions apply, the method checks whether they are syntactically equivalent.
Limitations
Patterns
Pattern A:
ClassA ClassB
objectPropertyS
Pattern B:
ClassA ClassB
objectPropertyS
1
30
Title
ties
Importance
level
Critical
Object properties
Datatype properties
Description
Examples
Event
Nation
takesPlaceIn
<<rdfs:domain>>
<<rdfs:range>>
City
<<rdfs:range>>
How to solve it
property, check:
For domains:
For ranges:
References
5
Code M2-P19. Detecting multiple domains or ranges in datatype properties
Pitfall
cardinality
Object properties
Datatype properties
Description
This method iterates over the list of datatype properties included in the ontology.
If a datatype property has more than one rdfs:domain axiom (pattern A) and the classes the domain
If a datatype property has more than one rdfs:range axiom (pattern B) and the datatypes the range
axioms refer to are not the same one, then a pitfall is flagged.
The method checks if the multiple classes declared as domain are the same class or equivalent classes. If
class restrictions apply, the method checks whether they are syntactically equivalent.
Limitations
Patterns
Pattern A:
ClassA ClassB
datatypePropertyS
The graphical pattern shows a datatype property
that has two rdfs:domain axioms defined.
Pattern B:
<<primitive>>
xsd:datatype1
datatypePropertyS
<<primitive>>
xsd:datatype2 The graphical pattern shows a datatype property
that has two rdfs:range axioms defined.
Structural pattern matching Pitfall affects to
Object properties
Datatype properties
Description
iterates over the list of object properties included in the ontology.
property has more than one rdfs:domain axiom (pattern A) and the classes the domain axioms
ot match, then a pitfall is flagged.
property has more than one rdfs:range axiom (pattern B) and the classes the range axioms
ot match, then a pitfall is flagged.
checks if the multiple classes declared as domain or range are the same class or equiva-
If class restrictions apply, the method checks whether they are syntactically equivalent.
Limitations
does not check if two different class restrictions or anonymous classes logically represent identical
duals.
Patterns
al representation and/or OWL code Natural language description
ClassB
wl:ObjectProperty>>
bjectPropertyS
>> <<rdfs:domain>>
ClassB
wl:ObjectProperty>>
objectPropertyS
>> <<rdfs:range>>
If an object property has more than one rdfs:range axiom
The method checks if the multiple classes declared as do
lent classes. If class restrictions apply, the method checks w
Limitations
The method does not check if two different class restrictions o
Patterns
Graphical representation and/or OWL code
Pattern A:
ClassA ClassB
objectPropertyS
The
has t
Pattern B:
ClassA ClassB
objectPropertyS
The
has t
Table 1: Detection method 1
1
Structural pattern matching Pitfall affects to
Object properties
Datatype properties
Description
iterates over the list of datatype properties included in the ontology.
e property has more than one rdfs:domain axiom (pattern A) and the classes the domain
to do not match, then a pitfall is flagged.
e property has more than one rdfs:range axiom (pattern B) and the datatypes the range
to are not the same one, then a pitfall is flagged.
checks if the multiple classes declared as domain are the same class or equivalent classes. If
ons apply, the method checks whether they are syntactically equivalent.
Code M2-P19. Detecting multiple domains or rang
Pitfall
cardinality
N Meth
Technique Structural pattern matching Pitfa
Description
This method iterates over the list of datatype properties inc
If a datatype property has more than one rdfs:domain ax
If a datatype property has more than one rdfs:range axi
axioms refer to are not the same one, then a pitfall is flagge
The method checks if the multiple classes declared as dom
class restrictions apply, the method checks whether they are
Limitations
The method does not check if two different class restrictions o
Patterns
Graphical representation and/or OWL code
Pattern A:
ClassA ClassB
datatypePropertyS
The
that
Pattern B:
<<primitive>>
xsd:datatype1
datatypePropertyS
<<primitive>>
xsd:datatype2 The
that
Table 5: Detection method 2
P19
description

Table of Contents
• Introduction
• Approach
• OOPS!
31

OOPS! – OntOlogy Pitfall Scanner!
32
§ Implements the 48 detection methods for 33
o Pitfalls selection
o Selection by dimensions and aspects
§ Web user interface http://oops.linkeddata.es/
§ Web service http://oops-ws.oeg-upm.net/
URI input
OWL
code
input

33
URI input
OWL
code
input
Importance level
Pitfall
description
Affected
elements

34
URI input
OWL
code
input
Importance level
Pitfall
description
Affected
elements
1. OOPS! USER INTERFACE AND WEB SERVICE
– oops:hasDescription: indicates the description of the suggestion value.
– oops:hasAffectedElement: this element will contain as many URIs as ele-
ments detected during the analysis.
Listing ?? shows an example of response provided by the web service in format
RDF/XML for the request shown in Listing ??. It can be observed that the request
indicated three pitfalls to be detected from which only two have been found.
1 <rdf:RDF
2 xmlns:rdf=" http: //www. w3 . org /1999/02/22´ rdf´syntaxńs#"
3 xmlns:owl=" http: //www. w3 . org /2002/07/ owl#"
4 xmlns:xsd=" http: //www. w3 . org /2001/XMLSchema#"
5 xmlns:oops=" http: //www. oegúpm. net /oops#"
6 xmlns:rdfs=" http: //www. w3 . org /2000/01/ rdf´schema#" >
7 <r d f : D e s c r i p t i o n rdf:about=" http: //www. oegúpm. net /oops#suggestion ">
8 <r d f : t y p e r d f : r e s o u r c e=" http: //www. w3 . org /2002/07/ owl#Class "/>
9 </ r d f : D e s c r i p t i o n>
10 <r d f : D e s c r i p t i o n rdf:about=" http: //www. oegúpm. net /oops/ fdea1aa6 ´71d6´4557´
a17a´dc3244ff536b ">
11 <oops:hasCode rdf:datatype=" http: //www. w3 . org /2001/XMLSchema#s t r i n g ">P10</
oops:hasCode>
12 <oops:hasName rdf:datatype=" http: //www. w3 . org /2001/XMLSchema#s t r i n g ">Missing
d i s j o i n t n e s s [ 1 , 2 , 3]</oops:hasName>
13 <oops:hasDescription rdf:datatype=" http: //www. w3 . org /2001/XMLSchema#s t r i n g ">
The ontology l a c k s d i s j o i n t axioms between c l a s s e s or between p r o p e r t i e s
that should be defined as d i s j o i n t .</ oops:hasDescription> <r d f : t y p e
r d f : r e s o u r c e=" http: //www. oegúpm. net /oops#p i t f a l l "/>
14 <oops:hasImportanceLevel rdf:datatype=" http: //www. w3 . org /2001/XMLSchema#
s t r i n g ">Important</ oops:hasImportanceLevel>
15 <oops:hasNumberAffectedElements rdf:datatype=" http: //www. w3 . org /2001/
XMLSchema#i n t e g e r ">1</ oops:hasNumberAffectedElements>
16 </ r d f : D e s c r i p t i o n>
17 <r d f : D e s c r i p t i o n rdf:about=" http: //www. oegúpm. net /oops /496 ae03d ´48c6 ´406d´8
d07´530bf05c9ac1 ">
18 <o o p s : h a s P i t f a l l r d f : r e s o u r c e=" http: //www. oegúpm. net /oops/ fdea1aa6 ´71d6
´4557á17a´dc3244ff536b "/>
19 <r d f : t y p e r d f : r e s o u r c e=" http: //www. oegúpm. net /oops#response "/>
20 </ r d f : D e s c r i p t i o n>
21 <r d f : D e s c r i p t i o n rdf:about=" http: //www. oegúpm. net /oops#p i t f a l l ">
22 <r d f : t y p e r d f : r e s o u r c e=" http: //www. w3 . org /2002/07/ owl#Class "/>
23 </ r d f : D e s c r i p t i o n>
24 </rdf:RDF>
Listing 1.4: Example of XML/RDF response from the web service

Pitfall coverage comparison with state of the art
35
Pitfalls OOPS! XD-Analyzer Moki OntoCheck
P02, P03, P05, P06, P10, P12,
P20, P21, P25, P26, P27, P28,
P29, P30, P31, P32, P33, P36,
P37, P38, P39, P40, P41
✔
P24 ≈
P13, P19, P34, P35 ✔ ✔
P07, P22 ✔ ✔
P11 ✔ ✔ ✔
P08 ✔ ✔ ✔ ✔
P04 ≈ ✔ ≈ ≈
P01, P09, P14, P15, P16, P17,
P18, P23
✔ Pitfall covered
≈ Pitfall partially covered

Most common pitfalls in ontologies
36
129$ 125$
86$
55$ 53$ 45$
19$ 13$ 12$ 11$ 6$
663$
378$
219$ 202$
134$ 133$ 115$ 108$ 88$ 73$ 69$
807$
694$
484$
446$
159$
100$ 80$ 76$ 55$ 37$
0$
0$
100$
200$
300$
400$
500$
600$
700$
800$
900$
P08.$M
issing$annota6ons$
verse$rela6onships$not$explicitly$declared$
P11.$M
issing$dom
ain$or$range$in$proper6es$
P04.$Crea6ng$unconnected$ontology$elem
ents$
P22.$Using$different$nam
ing$conven6ons$in$the$ontology$
P10.$M
issing$disjointness$
**P41.$No$license$declared$
P24.$Using$recursive$defini6ons$
P07.$M
erging$different$concepts$in$the$sam
e$class$
P12.$Equivalent$proper6es$not$explicitly$declared$
*P35.$Untyped$property$$
P19.$Defining$m
ul6ple$dom
ains$or$ranges$in$proper6es$
*P40.$Nam
espace$hijacking$$
*P34.$Untyped$class$$
*P30.$Equivalent$classes$not$explicitly$declared$
*P36.$URI$contains$file$extension$$
*P38.$No$OW
L$ontology$declara6on$$
P05.$Defining$w
rong$inverse$rela6onships$$
P20.$M
isusing$ontology$annota6ons$$
P02.$Crea6ng$synonym
s$as$classes$$
P25.$Defining$a$rela6onship$as$inverse$to$itself$$
P26.$Defining$inverse$rela6onships$for$a$sym
m
etric$one$$
P21.$Using$a$m
iscellaneous$class$$
P29.$Defining$w
rong$transi6ve$rela6onships$$
*P39.$Am
biguous$nam
espace$$
*P31.$Defining$w
rong$equivalent$classes$$
*P32.$Several$classes$w
ith$the$sam
e$label$$
P06.$Including$cycles$in$a$class$hierarchy$$
*P37.$Ontology$not$available$on$the$W
eb$
P27.$Defining$w
rong$equivalent$proper6es$$
P28.$Defining$w
rong$sym
m
etric$rela6onships$$
P03.$Crea6ng$the$rela6onship$“is”$instead$of…$
*P33.$Crea6ng$a$property$chain$w
ith$just$one$property$$
Number'of'ontologies'
Pi1all'
Pi1alls'appearance'in'ontologies'
Cri6cal$ Important$ Minor$
*$Pi[all$included$in$September$2013$(evaluated$410$ontologies)$
**$Pi[all$included$in$March$2015$(evaluated$over$329$ontologies)$
Pi[alls$without$*$have$been$evaluated$over$696$ontologies$since$November$2011$

International adoption and use
37
§ 60 Countries
§ 3000 times used

Adoption and use
38
§ Used at university courses
§ Used in scientific reports
o Evaluation and assessment
§ Used in companies
o Development and training
§ Integrated in other systems:
o 3 External: LOV, OntoHub, DrOntoAPI
o 3 OEG: Widoco, SmartCity ontology catalogue, OnToology

Table of Contents
• Introduction
• Approach
• OOPS!
39

Wrapping up
40
Pitfall
catalogue
§ 41 pitfall descriptions
§ Importance levels
§ Classification
§ Repair tips
Detection
methods
§ 48 methods
§ 33 pitfalls
OOPS!
§ Access for users and
systems
§ Broadly used and
adopted

Future lines of work
41
OOPS!
§ To integrate OOPS! within ontology
editors
§ To carry out a quantitative assessment
of OOPS!
Pitfall
catalogue
§ To maintain and extend
the catalogue
o Multilingualism
o Metadata
o Annotations
o Adapt to OWL 2
§ To establish relationships
between pitfalls
Detection
methods
§ To transform and compare
structural patterns with SPARQL
queries
§ To improve detection methods
(linguistic techniques)
§ To include the guidelines for
ontology repair
§ To improve scalability for
large ontologies
§ To use data during the
diagnosis
§ Diagnosis of the
data? Potential
integration with Loupe

Questions?
Thanks for your attention!
42

References
43
§ Poveda Villalón, M. (2016). Ontology Evaluation: a pitfall-based approach to ontology diagnosis (Doctoral
dissertation, ETSI_Informatica).
§ Poveda-Villalón, M., Gómez-Pérez, A., & Suárez-Figueroa, M. C. (2014). Oops!(ontology pitfall scanner!): An
on-line tool for ontology evaluation. International Journal on Semantic Web and Information Systems
(IJSWIS), 10(2), 7-34.
Icons made by Freepik from www.flaticon.com

OOPS! (ONTOLOGY PITFALL SCANNER!):
ON-LINE ONTOLOGY DIAGNOSIS
María Poveda-Villalón
Mari Carmen Suárez-Figueroa and Asunción Gómez-Pérez
Ontology Engineering Group.
Universidad Politécnica de Madrid.
mpoveda@fi.upm.es
Data Quality Tutorial – SEMANTICS 2016
12th September
This work has been partially supportedby the Spanish project"4V:volumen, velocidad, variedad y validez en
la gestión innovadorade datos” (TIN2013-46238-C4-2-R) and theEuropeanproject “Ready4SmartCities - ICT
Roadmap and Data Interoperability for Energy Systems in Smart Cities” (FP7-608711).
OOPS! website: http://oops.linkeddata.es
Twitter account: @OOPSoeg

OOPS!: on-line ontology diagnosis by Maria Poveda

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a OOPS!: on-line ontology diagnosis by Maria Poveda

Similar a OOPS!: on-line ontology diagnosis by Maria Poveda (20)

Más de semanticsconference

Más de semanticsconference (20)

Último

Último (20)

OOPS!: on-line ontology diagnosis by Maria Poveda