It is well-known that automated reasoning provides important support for tools in ontology engineering, particularly, revealing errors and unexpected (non-) entailments in models. This has been possible thanks to the standardisation of ontology languages and the subsequent development of tools and infrastructure to manipulate ontologies in such languages. However, in spite of the fact that nowadays reasoning systems are integrated into a huge range of these tools, their use for enhancing automated tasks in ontology engineering processes has not been fully explored in depth, particularly in closing the gap between graphical and formal representations of ontologies. In this work we detail two scenarios in which it is possible to take advantages of automated reasoning in this sense. The first scenario deals with the problem of tool interoperability, and the second analyses how to obtain non-trivial graphical inferences.
The cross-fertilisation between visual knowledge representation systems and logic
formalisms has been extremely productive since the research area of Description Logics (DLs)
emerged as a structured and well-understood way to provide a precise semantic
characterisation of frames and semantic network tools [
In the last years there have been important theoretical advances in precisely defining
the semantics and computational properties of diverse DL profiles[
In spite of the fact that nowadays reasoning systems are integrated into a huge range of tools, their use for defining or enhancing automated tasks is still undervalued. In this work we detail two scenarios and experiments in which we describe how to take advantages of the automated reasoning for ontology designing tasks and how it should be used considering the diverse reasoning tools, protocols and underlying languages support. In particular, we focus on how this can be applied to ontology engineering in the context of a visual tool. At the end of each scenario we present algorithms to tackle the found weaknesses, which take advantages of automated reasoning a visual tool. We outline on how diverse tools provide different approaches to manage ontology engineering tasks involving automated reasoning, creating a mismatch between the theory of precise semantics and the practice.
This work is structured as followed. Section 2 details the context in which our research takes place and including most relevant related works. Section 3 presents the scenarios, experiments and discussions about how automated reasoning is integrated to ontology engineering tasks. Section 4 presents final discussion and conclusions aiming at generating a deeper insight in visual-formal interactions.
Formalising the graphical and logical interaction has several advantages. First, it can be
used as a basis for design and implementation of novel graphical applications for
conceptual modelling and ontology engineering, providing a terminology and understanding
of the requirements for design and implementation of this kind of environment. Second,
it allows to evaluate and classify existing tools according to how they manage the
integration of both aspects (logical and visual). Third, it is useful for neatly characterising
the expressive power of any tool in both directions: visual and formal. In addition to
VADALOG and OBDA systems, there are other related tools in this approach,
particularly ICOM [
In addition, several of reviewed tools implement just a few ontology engineering tasks (only the popular Prote´ge´ is considered as an integrated ontology development tool), providing very different user interfaces, graphical and formal languages and reasoning capabilities. Generally, these processes appear to be fragmented across diverse tools and workarounds. This lack of adequate and seamless tools potentially hinders the broad uptake of ontologies by modellers not skilled in logics, especially OWL, as a knowledge representation formalism. As a consequence, this analysis gives a real insight into going towards an unified tool integrating not only the visual notations and their common features, but also supporting other activities of ontology engineering altogether in a single graphical and logical framework with a set of core functionalities.
In [
We present here two scenarios where automated reasoning can be integrated into
ontology engineering tasks in the context of visual environments. Particularly, we analyse
issues related to: (a) interoperability between tools in the context of importing tasks; and
(b) how the automated reasoning can be used for inferring new cardinality constraints in
a graphical model of an ontology. The aim of this evaluation is to state how the automated
reasoning can be applied to manipulating graphical ontologies. The scenarios of
evaluating are described first, and subsequently the results and discussion thereof. We will go
through simple examples, as shown in Fig. 1 in order to specifically show the issues that
we have tried to undertake. This simple ontology, which is adapted from one in [
Call o r i g i n
Phone 1..5 that mobile calls are a kind of calls; that phone points are partitioned between cell points and fixed points and that home points are among phone points. Mobile calls are related to cells through the mOrigin association. The binary association mOrigin is a included in the binary association origin. Finally, for a sake of simplicity, we will suppose for our example that each call has between one and five origin phones.
For this scenario, we consider importing in a tool an OWL 2 ontology from a OWL
2 document in OWL/XML syntax aiming at visualising it, i.e. exploring its concepts,
hierarchies and roles. Firstly, we present the case of Prote´ge´ for an ontology with two
equivalent representations for the domains and ranges of object properties. Finally, we
discuss and conclude about this issue and show an algorithm for importing OWL 2
ontologies, which aiming at accessing the OWL 2 documents through SPARQL-DL [
A possible encoding, following [
From the resulting DL formalisation, we can generate document V1 in Table 1 using OWL/XML syntax. Alternatively, we can use ObjectPropertyDomain and ObjectPropertyRange OWL/XML tags, resulting in document V2. Intuitively, both documents represent the same graphical and formal meaning, but after importing V1 in Prote´ge´, both domain and range axioms are imported as general axioms because the referred axioms cannot be directly associated with a named class. This is shown in Fig 2 (a). On other hand, importing of V2 is trivial because domains and ranges are displayed in the right view and associated to origin. Fig. 2 (b) shows its interpretation.
In Prote´ge´, general class axioms cannot be directly associated with a named class so
that they are not inferred as equivalent to domain and range of an ObjectProperty either
when importing. Furthermore, reasoners in the tool do not conclude this after checking
<ObjectPropertyRange>
<ObjectProperty abbreviatedIRI="origin"/>
<Class abbreviatedIRI="Phone"/>
</ObjectPropertyRange>
...
</Ontology>
gine is built on top of the Pellet reasoner [
We can see that general axioms expressing domain and range for a property
(as in the OWL document V1) can be properly represented in a visual tool when an
ontology is being imported. Tools built on top of the OWL API [
Outputs
}
}
// Get Domain for each OP
SELECT DISTINCT ?objectproperty ?domainop
WHERE {
ObjectProperty(?objectproperty),
Domain(?objectproperty,?domainop)
// Get Range for each OP
SELECT DISTINCT ?objectproperty ?rangeop
WHERE {
ObjectProperty(?objectproperty),
Range(?objectproperty,?rangeop)
{"domainop": { "type": "uri", "value":
"http://crowd.fi.uncoma.edu.ar#Call" },
"objectproperty": { "type": "uri", "value":
"http://crowd.fi.uncoma.edu.ar#origin"}}
{"domainop": { "type": "uri", "value":
"http://www.w3.org/2002/07/owl#Thing" },
"objectproperty": { "type": "uri", "value":
"http://crowd.fi.uncoma.edu.ar#origin" }}
{"rangeop": { "type": "uri", "value":
"http://crowd.fi.uncoma.edu.ar#Phone" },
"objectproperty": { "type": "uri", "value":
"http://crowd.fi.uncoma.edu.ar#origin"}}
{"rangeop": { "type": "uri", "value":
"http://www.w3.org/2002/07/owl#Thing" },
"objectproperty": { "type": "uri", "value":
"http://crowd.fi.uncoma.edu.ar#origin" }}
tools like OWLGrEd [
load OWL 2 document in crowd; execute SPARQL-DL queries on $OWL-file; get Classes from $answer ; 4 foreach $class in $classes do $subclass
$subclass [ getSubClass($class) get ObjectProperties from $answer; $triple-op
$triple-op [ ($op, getDomain($op), getRange($op)) get DataProperties from $answer; $triple-dp
$triple-dp [ ($dp, getDomain($dp), getRange($dp)) classes. 1 $OWL-file 2 $answer 3 $classes 5 6 end 7 $op-set 8 $triple-op 10 11 end 12 $dp-set 13 $triple-dp 15 16 end 9 foreach $op in $op-set do 14 foreach $dp in $dp-set do void; void; /* Composing the UML diagram: UML-D 17 foreach $class in $classes do map $class to a UML class in UML-D; 18 foreach $sbc in $subclass do map $sbc to a UML generalisation in UML-D; 19 foreach ($op,$dop,$rop) in $triple-op do map $op to a UML binary association between $dop and $rop with */ cardinality 0:: on both sides in UML-D; 20 foreach ($dp,$ddp,$rdp) in $triple-dp do map $dp to a UML attribute between $ddp and $rdp in UML-D; 21 send UML-D to graphical engine;
Aiming at providing an import functionality for a visual tool as crowd, we propose
to query the ontologies, e.g. using SPARQL-DL and reasoning, and thus identifying
axioms that can be mapped to graphical primitives. The pseudo-code in Alg. 1 shows the
algorithm in crowd for importing OWL 2 ontologies in order to visualise them. The
general idea of such algorithm is to get from an OWL 2 document all the classes, object
and data properties and any other axioms, which primitives in the underlying graphical
language can be mapped to. For instance, Equivalence and Disjoint axioms do not have
direct primitives in UML although they could be reconstructed from DL by adding
generalisations and additional classes, as demonstrated in [
As one limitation, this approach only takes into account monolithic ontologies, i.e.
ontologies saved into only one file, with no imports or mergers [
Determining implicit consequences is helpful: on the one hand, to reduce the complexity of the diagram by removing those parts that implicitly follow from other ones, and on the other hand it can be used to make properties explicit, thus enhancing its readability. In particular, the refinement of properties involves detecting stricter cardinality constraints from analysing how the properties of classes and relationships interact with each other. From a theoretical point of view, these cardinalities can be identified by exploring the DL axioms (by hand), however, this is rather complex when involving external reasoning tools. Reasoning services provide ways to query about satisfiability, subsumption, equivalence and disjointness of classes, object and data properties, although in some situations these services should be used along with specific axioms in order to provide more insights on the current model.
In this scenario, we revisit the conceptual model from Fig. 1, identify some implicit cardinalities based on a related approach from ICOM, and present an algorithm for manipulating and inferring these cardinalities on visual models in a concrete tool. First of all, in order to analyse cardinalities, we encode both UML association origin and mOrigin with its respective cardinalities (axioms 1-5), and also the UML generalisations (axioms 6-9), as follows.
M obileCall
P hone
mOrigin v origin
After handing these axioms to Prote´ge´ and reasoning over it, no new hidden axiom is revealed to the modeller. However, if we carefully analyse the diagram, we can conclude that it is necessarily true that each MobileCall may have an origin from at most five Cell. This is true because any pair in mOrigin is also among the pairs in origin and also each Call participates at most five times as first argument in origin. So that any generic subclass of Call and origin inherits the very same maximum participation. One more time, current reasoning systems do not detect this new conclusion in a direct way but they can help to extract this implicit knowledge from ontology by supporting other ontology engineering processes. Based on the ICOM proposal, where non-trivial graphical cardinalities are inferred by asserting new axioms for 0 and 1 during the DL encoding of a diagram, we propose a new process for generalising the previous one and thus inferring cardinalities greater than ICOM ones. First of all, our algorithm asserts these axioms to original model:
M obileCall mOrigin min M obileCall mOrigin max
m mOrigin) n mOrigin) where m is the minimum cardinality and n is the maximum cardinality. For our model, the following axioms are asserted:
M obileCall mOrigin min M obileCall mOrigin max
1 mOrigin) 5 mOrigin) (10) (11)
The general idea of this approach is to assert axioms such as (10) and (11) for each cardinality to be reviewed, choose the equivalents ones after reasoning and as a consequence, reveal the hidden constraints (if any). In this spite of the fact that the number of asserted axioms grows linearly on the number of binary association, it also depends on the minimum and maximum cardinality supported in the models, in which case the growth in the amount of axioms should be considered at the moment of evaluating the performance of a concrete tool. Still, we can consider this maximum cardinality number for all constraints in the model as a constant.
MobileCall_mOrigin_min
MobileCall_mOrigin_max MobileCall_mOrigin_min MobileCall_mOrigin_max origin
Phone MobileCall mOrigin
Cell
Fixed
Discussion Automated reasoning is key to ensure the quality of ontologies. Thus,
exploiting it in depth in order to make impact on the visualisation of ontologies is an aspect
relevant. In this case of study, we have analysed a feature not completely undertaken in
existing tools. Only ICOM [
In this work, we proposed a preliminary version of an enhanced algorithm, whose pseudo-code is sketched in Alg. 2 and currently implemented in our tool crowd. For a sake of space, we write the core of the algorithm leaving out other aspects about how stricter cardinalities are visualised back in a tool, which is a similar to the code in Alg. 1. The algorithm takes a UML input with n binary associations and a specific cardinality value, named card. After that, it asserts axioms as (10) and (11) for each cardinality value between 1 and card. Finally, when an answer returns from a reasoning system, the algorithm looks for axioms equivalent to domain and range of each association, which represent precise cardinality values. Under this approach, the number of new concepts is lineal to the number of associations in the input model, i.e. 4cardn, being being card the allowed maximum cardinality and n the number of associations in the input model. This upper bound is acceptable considering middle-size models, and mainly it relies on the capabilities of the reasoning tool for processing a potentially huge number of concepts and/or roles.
Algorithm 2 Reasoning on graphical ontologies in crowd
Result: A set of stricter cardinalities for each association in the graphical model 1 $diag Input UML graphical ontology in crowd with n associations; 2 foreach $class and $attribute in $diag do 3 $owlFile encodeOWL($class) ; /* each class is encoded in OWL */ 4 $owlFile encodeOWL($attribute); 5 end /* $card: threshold of max cardinality to be checked */ /* the algorithm incorporates 4 $card n classes to the initial UML */ 6 foreach $association in $diag do 7 $domain getDomain($association); 8 $range getRange($association); 9 for i = 1 to $card do 10 $domain min $domain min [ fdomain mini getName($domain) u ( i getName($association))g; 11 $domain max $domain max [ fdomain maxi getName($domain) u ( i getName($association))g; 12 $range min $range min [ frange mini getName($range) u ( i getName($association) )g; 13 $range max $range max [ frange maxi getName($range) u ( i getName($association)) g; $withCards $withCards [ f$domain ming [ f$domain maxg [ f$range ming [ f$range maxg;
Automated reasoning is a powerful way to help to users in modelling tasks, and simple examples are enough to see that integrating reasoning to ontology engineering processes should be explored in more depth. Along this final discussion, we revisit our starting motivation and extend the findings of this work by detailing about specific dimensions related to the use of automated reasoning in engineering tasks, and the need of defining standard ways of providing them in the context of visual tools.
About exploding the popular myth of interoperability Both described scenarios increase
the myth of the interoperability. Firstly, equivalent ontologies are not interpreted as
equivalents in Prote´ge´ but do in other tools querying the ontology differently, however, all
of them are built on top of the same OWL API. With reference to the second scenario,
the motivating issue is similar to the previous one. Approaches coming from the DL
reconstructions of CMDLs in classic ontology engineering fail at the moment of
visualising more expressive ontologies through standard languages. Non-standard languages
could be able to depict complex axioms and implicit properties but not in a user-friendly
way [
Defining standardised importing and exporting processes in tools The lack of a more
robust interoperability support in tools is closely related to the definition and
standardisation of tools and some ontology engineering processes. Making focus on tools in the
literature and particularly in visual ones, we see that both importing and exporting
processes are typical read from and write to OWL documents. This is fine in environments
where the content of these documents does not present semantic definitions. In particular,
tools are not considering this when importing OWL 2 document, leaving the
manipulation of the document to an API, which identify axioms according to OWL definitions. As
a conclusion, the already discussed standardisation of ontology languages [
About the use of automatic reasoning in visual tools Taking into account that the consequences of bad ontologies become more critical in real applications, we have to provide access to even more sophisticated tools for modelling ontologies in order to assure certain quality parameters. Visual aspects are fundamental in this sense because they help to modellers in detecting anti-patterns and debugging models. However, the increasing complexity of ontologies because of their size requires closely integrating both visual and automated reasoning in comprehensive engineering tasks. In this direction, we are working hard on crowd, which is a meta tool making use of graphical languages and reasoning in an environment for ontology engineering. Without being a silver bullet, crowd implements the algorithms presented in this work bringing together research on semantic formal and visual approaches for knowledge representation. Lastly, the tool is able to be interfaced to other ones (commonly, reasoners) for handing models to diverse systems that enabling possible different diagnoses and results.
As a conclusion, we present two novel algorithms derived from a number of experiments in related tools, which are implemented in a concrete visual tool, crowd, integrating automated reasoning in engineering tasks. These proposals aim to bring together research on two under-explored aspects to bad or good ontology design, particularly, techniques and tools for maintaining and manipulating good ontologies as well as explaining, and repairing bad ones.