In this paper we present Graphol, a novel language for the diagrammatic representation of Description Logic (DL) ontologies. Graphol is designed with the aim of offering a completely visual representation to the users (notably, no formulas need to be used in the diagrams), thus helping the understanding of people not skilled in logic. At the same time, it provides designers with simple mechanisms for ontology editing, which free them from having to write down complex textual syntax. Through Graphol we can specify SROIQ(D) ontologies, thus our language essentially captures the OWL 2 standard. In this respect, we developed a basic software tool to translate Graphol ontologies realized with the yEd graph editor into OWL 2 functional syntax specifications. We conducted some initial user evaluation tests, involving designers skilled in conceptual or ontology modeling and users without specific logic background. From these tests, we obtained promising results about the effectiveness of our language for both visualization and editing of ontologies.
Ontologies are widely recognized as the best means to share domain knowledge in a formal way. This implies that the representation they provide has to be agreed upon by all their users, so that ontologies can act as reference models across groups of people, communities, institutions, and applications. The relevance of this problem is also amplified by the increased uptake of ontologies in several contexts, such as biomedicine, life sciences, e-commerce, cultural heritage, or enterprize applications [25]. Obviously, it is very likely that people operating in such contexts are not experts in logic and generally do not possess the necessary skills to interpret formulas through which ontologies are typically expressed. This turns out to be a serious problem also (and probably mainly) in the development of an ontology. Indeed, ontologists usually work together with domain experts, the first providing their knowledge about ontology modeling and languages, the latter providing their expertise on the domain of interest. During this phase, communication between these actors is fundamental for the ontology to eventually become a formal specification which faithfully represents the domain requirements.
We also notice that, despite the recent popularity of ontologies, there is still a serious lack of designers with the right skills for their modeling. In this respect, analysts and experts in conceptual modeling for software and database design might be good candidates to compensate for this lack, provided that they are trained to acquire the needed knowhow. However, they need the right tools to approach the problem, possibly close in spirit to those they usually adopt for conceptual modeling.
In the past years, some efforts have been made in this direction, and graphical
syntaxes for ontologies based on the use of standard conceptual modeling languages have
been devised. In particular, UML profiles for OWL DL have been proposed in [
In this paper we present our proposal for the graphical representation of DL
ontologies and introduce the novel Graphol language. The main characteristics of Graphol
can be summarized as follows:
– Similarly to previous UML-based approaches, it is rooted in a standard language
for conceptual modeling. Indeed the basic components of Graphol are taken from
the Entity-Relationship (ER) model. Notably, simple ontologies that correspond to
classical ER diagrams (e.g., some ontologies specified in OWL 2 QL [23]) have in
Graphol a representation that is isomorphic to the ER one;
– Similarly to OWLGrEd, it is tailored to OWL 2, and thus it overcomes the limits of
previous UML profiles for OWL 1 and of other graphical notations for ontologies
1 http://protegewiki.stanford.edu/wiki/OntoGraf
2 http://protegewiki.stanford.edu/wiki/OWLViz
that capture less expressive DLs. More precisely, Graphol subsumes SROIQ(D),
the logical underpinning of OWL 2 [
To support the graphical modeling of ontologies and at the same time foster the interoperation with standard OWL reasoners and development environments, we have devised a process that leads the designer from the drawing of a Graphol diagram, through the use of the open source graph editor yEd3, to the production of the corresponding OWL 2 specification. We discuss these aspects in Section 3.
Finally, to verify the effectiveness of our language, we have conducted some user
evaluation tests, where both designers skilled in conceptual or ontology modeling and
users without specific logic background were involved. Our tests, though preliminary,
showed that Graphol has been perceived as a valuable and easy to use tool for both
ontology editing and visualization, and confirmed the importance for a visual
ontology language to be completely graphical, which is one of the distinguishing feature
of Graphol. A synthesis of our tests is given in Section 4, whereas for a complete
description of our evaluation study, we refer the reader to the full version of the present
paper [
Graphol syntax. The terms that make up the alphabet of the ontology, meaning the named concepts, roles, attributes, value-domains (i.e., predetermined datatypes), and constants (both individuals and values) are modeled by labeled rectangles, diamonds, circles, rounded corner rectangles, and octagons, respectively. These symbols are called predicate nodes, and the associated labels refer to predicates in the ontology alphabet.
We reserve two special labels, “Top” and “Bottom”, to represent, respectively, the universal concept, value-domain, role, or attribute, and the empty concept, valuedomain, role, or attribute. For instance, a rectangle labeled “Top” represents the universal concept (>C ), while a rectangle labeled “Bottom” represents the empty concept (?C ). Similarly for roles, attributes, and value-domains.
Other types of nodes, called constructor nodes, correspond to logical operators such as intersection, union, negation (i.e., complement of), or restrictions on the domain and 3 http://www.yworks.com/en/products_yed_about.html Restriction type inv chain
Name Concept node Value-domain
node Range restriction
node Inverse node Chain node
Symbol and oneOf
Name Inclusion edge
Name Role node Individual/
Value node Intersection node
One-of node
Symbol Restriction type or not
Name
Attribute node Domain restriction
node
Union node Complement node
Name Input edge Symbol
Symbol range of roles and attributes, and are used to graphically construct concept, role, attribute, or value-domain expressions. Graphol nodes are shown in the top part of Figure 1, where the “Restriction type” label of the domain and range restriction nodes can be equal to: “exists”, “forall”, “(x; )”, or “( ; x)”, where x is a positive integer.
In Graphol, an edge can be of two types: input edge or inclusion edge. The former is a dashed directed diamond edge, where the diamond indicates the target end, and is used to construct complex expressions in the ontology by linking constructor and predicate nodes. The latter is a solid directed arrow edge, where the arrow indicates the target end, and is used to represent an inclusion assertion between expressions. The input edge and the inclusion edge are depicted in the bottom part of Figure 1.
A Graphol expression is a weakly-connected acyclic directed graph, whose nodes are both predicate and constructor nodes and whose edges are only input edges, that has exactly one node with no outgoing edges. We call such node the sink of the expression. We recall that a directed graph is called weakly-connected if replacing all of its directed edges with undirected edges produces a connected (undirected) graph. The definition of expressions in our language is formalized below. In such definition, when we mention constructor nodes with input expressions we mean a (portion of a) graph where an input edge goes from the sink of the expression to the constructor node.
Definition 1. A Graphol expression is built through one of the following specifications. 1. A concept expression is a weakly-connected acyclic graph, defined as follows. – a concept node is a concept expression, whose sink node is the concept itself; – a domain or range restriction node, labeled “exists”, “forall”, “(x; )”, or “( ; x)”, with one input role expression and one input concept expression, is a concept expression, whose sink node is the domain or range restriction node; – a domain restriction node, labeled “exists”, “forall”, “(x; )”, or “( ; x)”, with one input attribute expression and one input value-domain expression, is a concept expression, whose sink node is the domain restriction node; – an intersection or union node with n 2 input concept expressions is a concept expression, whose sink node is the intersection node or the union node; – a complement node with one input concept expression is a concept expression, whose sink node is the complement node; – a one-of node with n 1 input individual nodes is a concept expression, whose sink node is the one-of node. 2. A role expression is a weakly-connected acyclic graph, defined as follows. – a role node is a role expression, whose sink node is the role itself; – an intersection or union node with n 2 input role expressions is a role expression, whose sink node is the intersection or the union node; – an inverse node with one input role expression is a role expression, whose sink node is the inverse node; – a complement node with one input role expression is a role expression, whose sink node is the complement node; – a chain node with n 2 input role expressions, each one labeled with i such that 1 i n and i 6= j for any two labels i and j, is a role expression, whose sink node is the chain node. 3. An attribute expression is a weakly-connected acyclic graph, defined as follows. – an attribute node is an attribute expression, whose sink node is the attribute itself; – an intersection or union node with n 2 input attribute expressions is an attribute expression, whose sink node is the intersection or the union node; – a complement node with one input attribute expression is an attribute expression, whose sink node is the complement node. 4. A value-domain expression is a weakly-connected acyclic graph, defined as follows. – a value-domain node is a value-domain expression, whose sink node is the value-domain node itself; – a range restriction node, labeled “exists”, with one input attribute expression is a value-domain expression, whose sink node is the range restriction node; – an intersection or union node with n 2 input value-domain expressions is a value-domain expression, whose sink node is the intersection or the union node; – a complement node with one input value-domain expression is a value-domain expression, whose sink node is the complement node; – a one-of node with n 1 input value nodes is a value-domain expression, whose sink node is the one-of node.
As usual in ontology languages and DLs, intentional axioms are specified through inclusions. In Graphol, an inclusion assertion is expressed through an inclusion edge going from the (sink node of the) subsumed expression to the (sink node of the) subsumer. In detail, a concept (resp., role, attribute, value-domain) inclusion assertion is obtained by linking two sink nodes of concept (resp., role, attribute, value-domain) expressions. Inclusion edges between expressions of different types (e.g., a concept expression with a role expression) are not allowed. Finally, we define a Graphol ontology as a set of Graphol assertions.
Graphol semantics. We start with Graphol expressions and give their semantics by
providing their representation in terms of DL expressions, which in turn have a
formal semantics [
In formalizing , we denote with sink(EG) the sink node of EG, and with arg(EG) the possibly empty set of Graphol expressions that are linked to sink(EG) by means of input edges. Then, we define as follows: – if sink(EG) is a concept, role, attribute, value-domain, or individual/value node labeled S, then (EG) = S4; – if sink(EG) is a domain restriction node labeled “exists” (resp., “forall”, “(x; )”, “( ; x)”), and arg(EG) = f RA; CV g, then (EG) = 9 ( RA): ( CV ) (resp., (EG) = 8 ( RA): ( CV ), (EG) = x ( RA): ( CV ), (EG) = y ( RA): ( CV )); – if sink(EG) is a range restriction node labeled “exists” (resp. “forall”, “(x; )”, “( ; x)”), and arg(EG) = f R; C g, then (EG) = 9( ( R)) : ( C ) (resp.
(EG) = 8( ( R)) : ( C ), (EG) = x ( ( R)) : ( C ), (EG) = y ( ( R)) : ( C )); – if sink(EG) is a range restriction node labeled “exists” and arg(EG) = f Ag, then (EG) = 9( ( A)) ; – if sink(EG) is a complement node and arg(EG) = f g, then (EG) = : ( ); – if sink(EG) is an intersection (resp. a union or a one-of node) and arg(EG) = Sin=1 i, then (EG) = din=1 ( i) (resp. (EG) = Fin=1 ( i), (EG) = f ( 1); : : : ; ( n)g); – if sink(EG) is an inverse node and arg(EG) = f Rg, then (EG) = ( ( R)) ; – if sink(EG) is a chain node and arg(EG) = f 1R; : : : nRg, where each iR, with 1 i n, is a Graphol role expression linked to sink(EG) by an input edge labeled i, then (EG) = ( 1R) ( 2R) ( nR).
Similarly, in order to provide the semantics of Graphol inclusion assertions, we
define a function that takes as input one such inclusion AG and returns its DL
representation. We denote with source(AG) the Graphol expression whose sink node is the
source of the inclusion edge in AG, and with target(AG) the Graphol expression whose
sink node is the target of the inclusion edge in AG. The function is thus defined as
(AG) = (source(AG)) v (target(AG)). Given a Graphol ontology OG, we are
able to translate it into a DL ontology ODL by applying to each assertion in OG. The
semantics of OG coincides with the semantics of ODL, for which we refer to [
In Tables 1 and 2 we provide an example of the application of the function to Graphol expressions of “depth” 0 or 1, i.e., expressions formed only by predicate nodes or by a constructor node taking as input only predicate nodes.
It is easy to see that any DL ontology produced by the function subsumes a SROIQ(D) ontology. Furthermore, the inverse of the functions and can be defined analogously, thus showing that SROIQ(D) is indeed subsumed by Graphol. 4 We assume the alphabets for concepts, roles, attributes, value-domains, individuals, and values to be pairwise disjoint, so that it is clear which kind of predicate S represents. Also, with a little abuse of notation, if S =“Top” (resp. S =“Bottom”), we assume the returns the correct DL universal (resp. empty) predicate, depending on whether sink(EG) is a concept, role, attribute, or value-domain.
Expression Atomic Concept Domain restriction on role Range restriction on role Domain restriction on attribute Concept Intersection
Concept Union
Attribute Attribute Intersection
Attribute Union Attribute Complement
Value-domain
Range existential restriction on attribute Value-domain
Intersection Value-domain Union Value-domain
Complement
A 9R:C 8R:C xR:C xR:C 9R :C 8R :C xR :C xR :C 9U:V 8U:V xU:V xU:V
C u D C t D
:C fa; b; cg
R Q u R Q t R
R :R
Q R
U U1 u U2 U1 t U2 :U1
V 9U V1 u V2 V1 t V2 :V f1; 2; 3g
Shortcuts. In order to aid the user in the design of a Graphol ontology, we have defined some shortcuts that allow for a more compact representation of frequently used expressions and assertions. Here we introduce two of them.
The first shortcut is the disjoint union node, which is shaped as a black hexagon. This special node is used to represent a union expression, and at the same time it imposes the disjointness between its arguments. Therefore, it also represents negative inclusion assertions involving its arguments. An example of its use is given in Figure 2.
We also define a new edge, called global functionality edge. which is an input edge with an additional vertical line on its source end. It is used to define the functionality of a role (resp. an inverse role), by linking it to a domain (resp. range) “exists” restriction node. Similarly for the functionality of an attribute. An example is given in Figure 3.
Example. In Figure 4, we provide the Graphol specification of a portion of the Pizza ontology. We also present below a logically equivalent representation of such ontology given in terms of DL assertions.
CheeseT opping v P izzaT opping F ood v 9calories CheeseT opping v :M eatT opping P izza v F ood M eatT opping v P izzaT opping P izza v :P izzaT opping M eatT opping v :CheeseT opping CheeseyP izza v P izza P izzaT opping v F ood M eatyP izza v P izza P izzaT opping v :P izza M eatyP izza v :V egetarianP izza V egetarianP izza v P izza 9hasIngredient v F ood 9hasIngredient v F ood hasT opping v hasIngredient 9hasT opping v F ood 9hasT opping v P izzaT opping 9calories v F ood 9calories v xsd : integer V egetarianP izza :hasT opping:M eatT opping As a must-have for Graphol, we singled out the importance of having an automated translation tool to produce OWL 2 specifications from Graphol ones that are compatible with this standard. We also tried to provide this new language with an easy way to design, edit, and debug the graphical specifications. To these aims, we devised a process for ontology designers that relies on both existing open source tools and originally developed software components.
The process starts specifying, by means of the yEd editor, a Graphol diagram, encoded in the graphml format5. The use of a third party software provides the developers with a large set of features, professionally devised for supporting the editing of diagrams of all sorts. To further support editors, we packed up a yEd palette containing all and only the symbols needed for editing a Graphol ontology. This comes in handy in trying to overcome the lack of specificity of the editor.
We then implemented a tool capable of translating a set of yEd diagrams specifying a Graphol ontology into an equivalent OWL 2 encoding, if any. More precisely, the tool is devised to be both a support for the editing tasks and an automatic translator that produces an OWL 2 functional syntax specification. The latter is achieved by parsing the yEd files and translating each portion with the corresponding OWL statement, straightforwardly applying the rules sketched in Section 2. As for the editing aids, the tool provides a syntactic validation of a given diagram. While parsing, if a portion of the graph is found such that either it is non well-formed, i.e., it does not respect the Graphol syntax, or does not correspond to any OWL 2 statement, the process terminates. If the translation was not successful, the tool shows, by means of an external yEd viewer, one of the nodes in the identified untranslatable portion and describes the recognized error in a pop-up window. Both the translator tool and the yEd palette for Graphol can be downloaded from the web site http://www.dis.uniroma1.it/˜graphol/. 4
In this section we briefly discuss the user evaluation tests we have conducted for the Graphol language. The goal of these tests is to evaluate the effectiveness of Graphol 5 http://graphml.graphdrawing.org/index.html for ontology comprehension and design by users with different backgrounds and varying levels of expertise. To achieve this goal, we have conducted two separate studies, designed around a series of model comprehension and model editing tasks which were performed individually by the participants.
– The first is a comparative study in which participants were asked to perform two series of eight comprehension tasks on two ontologies modeled respectively in Graphol and in a different graphical ontology language. For this study we chose a group of ten computer science Ph.D. and Master’s students with only basic skills in conceptual modeling, and whose experience with ontologies (if any) is limited to working with ontologies defined by others. We refer to this group as ontology consumers. – The second is a non-comparative user study in which participants were asked to answer ten questions and to perform ten editing tasks on two Graphol ontologies. For this study we selected a group of twelve computer science Ph.D. students, postdocs, and researchers with advanced knowledge in conceptual modeling and some basic skills in logic (but only a small subset of them with some experience in ontology design). We refer to this group as ontology designers.
We point out that the number of participants to both our evaluation study is in line
with guidelines on usability testing [
The language we chose for the comparative study was OWLGrEd [
We avoided extending the second study with comparative test between Graphol and OWLGrEd for ontology editing purposes because this test would have been strongly influenced by the tools used for the task, and an evaluation of these tools was outside the scope of the experiments (in particular because OWLGrEd comes with its own editor while Graphol currently does not). Furthermore, on a more practical note, this would have excessively drawn out the duration of the test (as it is, it exceeded two hours). We also did not conduct a comparative evaluation of Graphol against ontology editors such as Prote`ge`, or simply against modeling through DL axioms, because these approaches obviously do not offer graphical editing solutions, whereas our main aim has been to test the evaluation of consumers and designers not necessary skilled in ontologies.
In Figure 5 we provide some of the results we obtained through our tests. From left to right, the figure shows the average results in terms of correctness (percentage of correct answers) for the comprehension tasks in Graphol and OWLGrEd conducted by ontology consumers, the average correctness results for the comprehension and editing tasks in Graphol conducted by ontology designers, and the overall average times for the Graphol comprehension and editing tasks (in minutes, where 2.5 minutes for comprehension questions and 4 minutes for editing questions were the predetermined benchmark values). Clearly, the very high average correctness scores and low average times produced by the ontology designers in both tasks show an excellent comprehension of the Graphol language by these users, and a good ability in performing the required 4 3,5 3 2,5 2 1,5 1 0,5 0 100,0% 75,0% 50,0% 25,0% 0,0% 100,0% 75,0% 50,0% 25,0% 0,0% Ontology Consumers: Average Correctness
Ontology Designers: Average Correctness 74,50% 74% 84% 75% 2,51 Graphol Comprehension OWLGrEd Comprehension
Graphol Comprehension
Graphol Editing
Graphol Comprehension
Graphol Editing Graphol ontology modeling tasks. Furthermore, the ontology consumers, who did not have advanced knowledge on conceptual modeling, nevertheless showed a good level of comprehension of the Graphol language, comparable to, and in some cases better than, the one showed for OWLGrEd, which is strongly based on a formalism which they were familiar with. According to our results and to the feedback we obtained by users from several open questions that were presented in a post-test questionnaire and from a brief discussion that concluded the tests, we also observed that Graphol has been perceived as easier than OWLGrEd for more complex expressions, which in OWLGrED require the use of Manchester syntax formulas. 5
Besides the user evaluation tests we have described in Section 4, we could assess the
effectiveness of Graphol also through its use in some industrial projects in which we
have been recently involved (see, e.g., [
Both user evaluation tests and practical experience however have highlighted the
need of a dedicated editing tool specifically built to support the Graphol ontology
specification. The development of such tool is our main future work on Graphol. At the same
time, we are working to improve Graphol visualization. A first step on this direction has
been the use of a specific component for visualizing Graphol ontologies in Mastro
Studio [
OMG (2009), available at http://www.omg.org/spec/ODM/1.0 25. Staab, S., Studer, R. (eds.): Handbook on Ontologies. International Handbooks on Information Systems, Springer, 2nd edn. (2009)