Henriette's Notes

Home » Semantic technologies

Category Archives: Semantic technologies

DBPedia Extraction Framework and Eclipse Quick Start

I recently treid to compile the DBPedia Extraction Framework. What was not immediately clear to me is whether I have to have Scala installed. It turns out that having Scala installed natively is not necessary, seeing as the scala-maven-plugin is sufficient.

The steps to compile DBPedia Extraction Framework from the command line are:

  1. Ensure you have the JDK 1.8.x installed.
  2. Ensure Maven 3.x is installed.
  3. mvn package

Steps to compile DBPedia Extraction Framework from the Scala IDE (which can be downloaded from Scala-ide.org) are:

  1. Ensure you have the JDK 1.8.x installed.
  2. Ensure you have the Scala IDE installed.
  3. mvn eclipse:eclipse
  4. mvn package
  5. Import existing Maven project into Scala IDE.
  6. Run mvn clean install from within the IDE.


In this post we will look at how different types of inheritance can be translated to OWL. We consider the case where Person is specialized by Employee and Client (Fig. 1). In a UML class diagram if inheritance is not annotated the default annotation {incomplete, disjoint} is assumed. incomplete means there are instances of Person which are neither of type Employee nor Client. disjoint means there is no instance of Person that is both of type Employee and of type Client. The set representation is given in Fig. 2 and the OWL translation in Fig. 3.


Fig. 1


Fig. 2


Fig. 3

The annotation {complete, disjoint} means every instance of Person is either a instance of Employee or an instance of Client(Fig. 4). The corresponding Venn diagram is  given in Fig. 5 and the OWL translation in Fig. 6.


Fig. 4


Fig. 5


Fig. 6

When overlapping is used rather than disjoint it means an instance of Person may be both of type Employee and of type Client.  Fig. 7 – 9 provides a UML class diagram, Venn diagram and OWL translation as example for the annotation {incomplete, overlapping}. Fig. 10 – 12 provides a UML class diagram, Venn diagram and OWL translation as example for the annotation {complete, overlapping}.


Fig. 7


Fig. 8


Fig. 9


Fig. 10


Fig. 11


Fig. 12

A Brief Introduction to Protégé and Reasoners

A question you rightfully may be pondering is: Why translate object oriented classes into OWL? The answer is that it can help you to find logical inconsistencies in your class designs. In this post I will introduce the tools that will eventually enable you to find logical inconsistencies in your class designs.

The tool we will use is called Protégé. Download and installations instructions for Protégé can be found at https://protegewiki.stanford.edu/wiki/Install_Protege5.

In this post I will provide two screencasts:

  1. In the first screencast I will show you how to enter the OWL representation of the Person class introduced in the previous post.
  2. In the second screencast I will show you how to run a reasoner and how an inconsistency can arise.

On to the first screencast:

  1. Create a Person class.
  2. Create the data properties.
    1. name
    2. surname
    3. age
  3. Through sub-classing state that the Person class necessarily have a
    1. name,
    2. surname and
    3. age.
  4. If we run the reasoner on this ontology, no inconsistencies will be found.

In the second screencast I show how an inconsistency can arise. The steps are as follows:

  1. Create an individual called sarah of type Person.
  2. Run the reasoner. You will see the reasoner give no errors (nothing happened). This may come as a surprise to you since we have not set the name, surname or age data properties for the individual called sarah. In OWL this behaviour is expected due to what is called the open world assumption. OWL makes no assumption with regards to knowledge that is not stated explicitly. Since we did not state that the sarah individual does not have, for example, a name, the reasoner found no error in our ontology. This is different from typical database behaviour where absence of information is often assumed to indicate that the information does not exist, which is referred to as the closed world assumption.
  3. Now let us change our sarah individual to state that it does not have a name. This is achieved by stating that the sarah individual is of type name max 0 xsd:string. This states that the sarah individual can have a maximum of 0 name data properties of type xsd:string.
  4. If we run the reasoner now it shows that we have an inconsistency. We can ask Protégé to explain the inconsistency.ExplainSarahInconsistency
  5. The explanation states that sarah is of type Person and of type name max 0 xsd:string. But Person is a subclass of name some xsd:string. This states that individuals of type Person must have at least 1 name property of type xsd:string. Hence, the reason for the inconsistency.


Admittedly this example is contrived: there is not much sense in creating a Person class which we state must have a name and then create an individual of type Person which we then state does not have a name. But this was done here to show you how to use a reasoner to find inconsistencies in your ontology and to show you what information you can expect when your ontology is inconsistent.

Add Some More Attributes

Person with added attributes


In this post what I want to do is add some attributes to the Person class of the previous post. The important thing to understand is that as you add attributes to a class, what you are doing in effect is adding additional constraints that will cause the number of objects that can be of that type to shrink. This is illustrated in the Venn diagram below. Note that our Person class is now a subset of the intersection of the sets of objects with name as attribute, surname as attribute and age as attribute.


Person with more attributes subset


If we now consider the OWL 2 representation of this class in Manchester syntax, it matches our Venn diagram exactly. It further states that name, surname and age are properties. It states that individuals of the Person class have a name property of type xsd:string, a surname property of type xsd:string and a age property of type xsd:integer.


Add some attributes OWL

A Simple Class

A Simple Class

Let us start with a simple example. Assume we have a Person class, which models a person that has a name. Let us just think about what this means. If we think of our domain of interest and we list all the objects of the domain, some objects will belong to a set that is a subset of the domain of interest, which is called the Person set, which is represented by our Person class. Our Person class also has a name attribute of type String, but it is likely that we will have other classes in our domain that may have a name attribute of type String. Thus, the Person class represents objects that are a subset of all the objects in the domain that have a name attribute of type String. This is shown in the Venn diagram below.

Person Subset


Note that the Person class is not necessarily a strict subset of the objects that have a name attribute of type String. It is possible that the Person class is the only class in our domain that has a name attribute of type String, in which case these two sets are in fact equal.

The OWL 2 equivalent representation in Manchester syntax is given in the image below. Note that for the name attribute in the UML class we have defined a related DataProperty. Furthermore, a Person class is also defined, which is defined as SubClassOf: name some xsd:string. What this means is that individuals that belongs to the Person class also belongs to the class of individuals that have a name property of type xsd:string. Thus, the Person class is a subclass of the class representing individuals that have a name property of type xsd:string.

Person Manchester

The Correspondence between DLs/OWL and OO

The analogy between DLs and object-orientation can be observed when it is considered that the basic task in constructing an ontology is classification. Explicit subsumption relationships between concepts can be defined in the TBox. In object-orientation this can be achieved by definition of an inheritance hierarchy between classes. Classification is further solidified as the basis of DLs in that the core reasoning capabilities they provide are subsumption and instance checking. Subsumption computes a subsumption hierarchy, which essentially categorizes concepts into superconcept/subconcept relationships. Instance checking verifies whether a given individual is an instance of a specific concept [1].

In object-orientation the domain of interest is described in terms of classes that have properties, which are defined via attributes and/or associations. Classes in essence have a set-theoretic semantics, i.e. a class represents a set of objects in the domain of interest which shares attributes. Objects that are classified by a class are called instances of the class. The analogy with DLs is that classes, attributes/associations and instances (or sometimes called objects) correspond respectively with concepts, roles and individuals in DLs, which in OWL corresponds respectively to classes, properties and individuals.

This correspondence between object orientation, DLs and OWL 2 is summarized in the table below.

Object orientation DLs OWL 2
Class Concept Class
Attribute/association Role Property
Object Individual Individual


[1] F. Baader, D. Calvanese, D. L. McGuinness, D. Nardi and P. F. Patel-Schneider, The Description Logic Handbook: Theory, Implementation and Applications, Cambridge University Press, 2007.

What are Description Logics?

Description logics (DLs) are syntactic variants of first-order logic that are specifically designed for the conceptual representation of an application domain in terms of concepts and relationships between concepts [1].

Expressions in DLs are constructed from atomic concepts (unary predicates), atomic roles (binary predicates) and individuals (constants). Complex expressions can be built inductively from these atomic elements using concept constructors. Formally a concept represents a set of individuals and a role a binary relation between individuals [2].


Formally every DL ontology consists of a set of axioms that are based on finite sets of concepts, roles and individuals. Axioms in a DL ontology are divided into the TBox, the RBox and the ABox. A TBox is used to define concepts and relationships between concepts (that is the terminology or taxonomy) and an ABox is used to assert knowledge regarding the domain of interest (i.e. that an individual is a member of a concept). Depending on the expressivity of the DL used, an ontology may include an RBox. An RBox is used to define relations between roles as well as properties of roles [2].


A feature of DLs is that they have decidable reasoning procedures for standard reasoning tasks.  This means these reasoning procedures will give an answer, unlike undecidable reasoning procedures which may not terminate and thus may not give an answer.  A fundamental goal of DL research is to preserve decidability to the point that decidability is considered to be a precondition for claiming that a formalism is a DL. Standard DL reasoning algorithms are sound and complete and, even though the worst-case computational complexity of these algorithms is ExpTime and worse, in practical applications they are well-behaved [3].


Standard reasoning procedures for DLs are the following [2].

  • Satisfiability checking checks that every axiom in an ontology can be instantiated. Axioms that cannot be instantiated indicates that modelling errors exist within the ontology.
  • Consistency checking checks whether there are axioms that contradict each other, which again is indicative of modelling errors.
  • Subsumption checking checks whether an axiom subsumes another axiom, which is used for classifying axioms into a parent-child taxonomy.


Various DLs exist with different levels of expressivity and computational complexity. The most widely supported DL is SROIQ(D) which forms the mathematical basis of the W3C OWL 2 standard [4]. In OWL concepts are referred to as classes, roles are referred to as properties and individuals are still referred to as individuals.


In subsequent posts I will provide an intuitive understanding of OWL 2 and explain some of its uses. If you are using OWL or other semantic technologies, I will love to hear from you. Please leave a comment and feel free to explain the novel ways in which you use semantic technologies.



[1] D. Berardi, D. Calvanese and G. De Giacomo, “Reasoning on UML class diagrams,” Artificial Intelligence, vol. 168, no. 1-2, p. 70–118, 2005.

[2] F. Baader, D. Calvanese, D. L. McGuinness, D. Nardi and P. F. Patel-Schneider, The Description Logic Handbook: Theory, Implementation and Applications, Cambridge University Press, 2007.

[3] F. Baader, “What’s new in Description Logics,” Informatik-Spektrum, vol. 34, no. 5, p. 434–442, 2011.

[4] W3C, “OWL 2 Web Ontology Language – Document Overview (Second Edition),” W3C, 11 December 2012. [Online]. Available: https://www.w3.org/TR/owl2-overview/. [Accessed 9 September 2017].