G9_Cognition-Knowledge Rep and Reas_H6

Murillo P., de la Cruz M., Prieto H / Procedia Computer Science 00 (2015) 000–000
Knowledge Representation and Reasoning in Autonomous
Underwater Vehicles
Pablo Murillo, Marta de la Cruz, Héctor Prieto
Abstract
In collaborative robots is necessary an efficient and robust Knowledge Representation and Reasoning system. In this paper, a
KR&R system based on Semantic Web is presented and is proposed an upper KR&R system to coordinate missions in aquatic
environments. As aquatic environments are dynamic, Autonomous Underwater Vehicles (AUVs) need to deal with non-
programed situations which bring the system to manage incompleteness and uncertainties. In this work different Semantic Web
technologies are studied in order to build a “global KR&R system”. Our case of study is focused on collaborative AUVs which
carry out missions for the mines treatment in the ocean. To make it possible, three different types of AUV have been proposed:
search AUV (sAUV), inspection AUV (iAUV) and execution AUV (eAUV). The “global KR&R system” manages mission-
related knowledge. Protégé has been used to implement this proposed system and Pellet has been used as the reasoner.
KR&R; AUV; Semantic Web; Ontology; RDF; OWL; SPARQL; SWRL; RIF; Reasoning; Protègè; Pellet;

1. Introduction
Knowledge Representation and Reasoning (KR&R) is a field of Artificial Intelligence (AI) that represents
information about the world in the way that it is useful for a computer system so that it can solve complex tasks such
as diagnosing a medical condition or having a dialog in a natural language and it has a high impact in applications
like data mining, search engines and recommendation systems [1].
KR&R incorporates, from psychology, how humans solve problems and represent knowledge in order to design
formalisms to make easier complex systems [1].
In [2] it is said that “an Autonomous Underwater Vehicle (AUV) is a robot which travels underwater without
requiring input from an operator”.
This document will focus on how to represent the knowledge in underwater environments, in other words the
techniques of KR&R in AUVs, and the methods and algorithms for understanding this knowledge in cooperative
robots. And a case of use will be presented in the last section in order to exemplifier the algorithms and protocols
studied in the previous sections.
2. State of the Art
This section present a brief resume about robots history and the state of the art about KR&R and semantic Web and
how it is useful in robotics.
In 1993 Randall Davis of MIT described 5 roles to analyze a KR&R framework [3]:
• A knowledge representation (KR) is fundamentally a substitute for the thing itself, which make the entity
determine consequences by thinking instead of acting, i.e., by reasoning about the world rather than taking
action in it. It is a set of ontological commitments, i.e., an answer to the question: How should I think about
the world?
• It divides intelligent reasoning in three components:
• The representation's fundamental conception of intelligent reasoning.
• The set of inferences the representation sanctions.
• The set of inferences it recommends.
• The computational environment in which thinking is set must have a pragmatic efficiency.
• It is a medium of human expression, i.e., a language in which we say things about the world.
2.1 KR&R Systems
The first thing to do when deploying a knowledge representation system is choosing a suitable formalism in order
to express knowledge in a way it could infer more knowledge from it. A formalism must be defined over an explicit
Formal Language, going from pure mathematics First Order Logic “FOL” (the most expressive language in logics)
to subsets of it (like if-then structures based logic) or any other less expressive one. The decision of the expressive
power of the formalism will be determinant in our future goals, and it must be adapted to each use case [3].
A KR&R System will be composed of:
• Data “structures”: Higher level ones, because “low level” data structures will be dependent on which OS
and hardware is running the KR system.
• KR&R Primitives: FOL, sub-sets of FOL, Semantic Networks, Frames & Rules….
• Algorithms: i.e. general search, querying, meta-representation, handling incompleteness and
inconsistencies, non-monotonic reasoning tools... [3] [4].
Every one of this elements must be chosen carefully or even developed depending on the characteristics and
requirements of each use case [4].

Historically there have been, not only different Knowledge Representation Primitives, but so many different
approaches to the KR problem. Psychology, Philosophy and other fields have had different phases in which ones the
KR problem was considered under different points of view, but since 80´s semantic theorists support a language-
based construction of meaning [4].
But first computerized KR works was focused in general problem solvers (like “GPS”, Newell, Simon 1959), this
systems had a constrained “toy” domain because of the amorphous problem definitions they worked with. [5]
It was the failure of these efforts that led to the cognitive revolution in psychology and to the phase of AI focused on
knowledge representation that resulted in Expert Systems in the 1970s and 80s [4] (considered as the first truly
successfully forms of AI software),[4][6] Production Systems and, later in the mid 80´s, Frame Languages. Until
then, the most used “non-FOL” KR Primitives was Semantic Maps, but then many Expert Systems (using the LISP
programming language which was modelled after the lambda calculus) often used lambda calculus as a form of
functional knowledge representation. [4][7] Frames and Rules were the next kind of primitive.
Progressively the integration of Frames and Rules-based systems appears because there was an obvious synergy
between their approaches, an example is the Knowledge Engineering Environment “KEE” developed by IntelliCorp
in 1983 which drove to the integration of Object Oriented Programming with Frames and Rules. [4][8]
At the same time as this was happening, there was another field of research which was less commercially focused
and was driven by mathematical logic and automated theorem proving. The technique they used for primitives is to
define languages that were modelled after First Order Logic (FOL). The most well-known example is Prolog but
there are also many special purpose theorem proving environments, other of the most historically influential
languages in this research was KL-ONE (mid 80's) [4].
Currently one of the most active areas of knowledge representation research are projects associated with the
Semantic web. [4][9]
2.2 KR&R in Semantic Web
“The Semantic Web is an extension of the Web through standards by de World Wide Web Consortium (W3C). The
standards promote common data formats and exchange protocols on the Web, most fundamentally the Resource
Description Framework [...]The Semantic Web provides a common framework that allows data to be shared and
reused across application, enterprise, and community boundaries" [10]
There are some limitations of HTML in the semantic web so that the semantic web takes the solutions further. It
involves publishing in languages specifically designed for data: Resource Description Framework (RDF), Web
Ontology Language (OWL), and Extensible Markup Language (XML) [10]
The architecture of semantic web is shown in the next figure.

Figure 1: The semantic Web Architecture [10]
A brief definition [10] about each level is defined here but the most important languages are describing in the next
point.
• XML contribute with an elemental syntax for content structure in documents.
• RDF is a language used for expressing data models.
• RDF Schema is a vocabulary for describing properties and classes of RDF-based resources with semantics.
• OWL is a language which adds more vocabulary for describing properties and classes, for example
relations between classes.
• SPARQL is a protocol and query language for semantic web data sources.
• RIF defines the format of the interchange rules. It is an XML language for expressing web rules.
KR&R is a key technology for the Semantic web. Languages based on the Frame model with automatic
classification provide a layer of semantics on top of the existing Internet. Rather than making typical searches via a
simple text, it will be possible to define logical queries and find pages that map to those queries. The automated
reasoning component in these systems is an engine known as the classifier. A classifier can deduce new classes and
dynamically change the ontology as new information becomes available. This capability is ideal for the ever
changing and evolving information space of the Internet [1].
2.3 KR&R in Robotics
The field of KR&R is starting to be integrated in robotics, to make robots able to represent, use, exchange and
reason about knowledge [1]. Some examples are:
• The representation of higher level concept in semantic maps, that integrate several types of knowledge,
for example, geometric, topological, functional, categorical, temporal, etc.

• The use of ontologies to enable robots to induce information from the web.
Guarantee a high level of communication and synergy between robotics and the field of KR&R is essential in order
to use the large amount of knowledge, experience and tools acquired [1].
The two main points in this context are:
• Knowledge should be represented in an explicit way inside the robot, using suitable representation
formalism.
• The elements in this representation must be based in real physical objects, parameters, and events in
the robot’s operational environment [1].
2.4 Problematic
In the use case of Cooperative AUV´s for MCM missions, robots require sophisticated and robust concept and
knowledge management capabilities if they need to individually acquire knowledge, communicate it, and learn
it from another ones, exhibiting intelligent group behavior [2][11].
Semantic approaches had a proven added value for other multi-agent cooperative systems, two of them referenced in
[12] [13]. Semantic Web technologies and tools provide a bridge between individual perception and upper symbolic
levels (the semantic language which robots finally use to store knowledge and communicate or learn it from another
ones) grounding sensory and symbolic information into semantic shared knowledge in a hierarchy structure [13].
This means that, even when each robot maintain his own different ontologies, and use them to store and use his own
knowledge, they are able to share it in a form that only the receivers needs to "translate" it using the existing upper
ontologies, just if they do not understand at all some of the "definitions" the sender used.
However, most of the current KR systems for AUV´s generally target mono-domain simple applications, like
gathering data from sensors in order to be offline and manually post-processed. So they do not need more than a
very simple KR&R system. If it is necessary higher levels of autonomy and distributed work, as it is on our case of
use, MCM missions using collaborative AUV´s when they are going through a previously planned mission, robots
require access to higher levels of knowledge representation in order to increase group, adaptation, and
efficiency during mission accomplishment. So they need a global KR&R system if they are to efficiently infer,
share or request global mission-related knowledge between agents [2][11]. The Semantic Web technologies and
researches focused from the start in the possibility of multi-ontology systems [14] [13], so they are able to deal with
heterogeneous data which may need to be combined for many purposes.
2.5 Conclusions
The field of KR&R, and specially the semantic approaches, are starting to be an important part in many fields of
robotics. Semantic approaches and ontologies are being widely used in many recent AUV researches, some of them
referenced in [14] [15] [16] and projects referenced in [17] [18] to make robots being able to efficiently represent,
use, exchange and reason about shared knowledge [1] and in order to increase the autonomy levels and efficient
cooperation.
In this work we will try to analyze all the mentioned advantages that might be achieved with the use of Semantic
Web technologies in order to improve MCM Collaborative AUV´s mission accomplishing.
3. Proposed KR&R System
In this section a case of use is presented in order to analyse KR&R requirements. The case of use is set
developed in a subaquatic environment.
The target is to deactivate mines lost in the sea during the Second World War. To achieve this mission a set of teams
of AUVs are going to cooperate. It can be difference three types of AUVs:

1. SAUV: Search AUV: this AUV have the target of mapping the environment and to mark potential targets.
2. IAUV: Inspection AUV: once the SAUV has finished its mission, this AUV has the target of determinate if
the potential targets are or not clear objectives.
3. EAUV: Execution AUV: once both the SAUV and the IAUV has finished its mission, this AUV has to go to
the objective and detonate the mine if it is possible.
The initial state of the SWARM will require some kind of training or pre-programming of the needed global
missions and sub-missions procedures and/or parameters.
Each AUV will have its mono-domain KR&R system, which will not be analyzed in the present work, but will
describe mechanisms for maintaining a distributed KR&R System that might work with all mono-domain
knowledge in a dynamic way. So, for example, we might have the global knowledge base and reasoning tools for
dynamically representing and using the knowledge associated to the global accomplishment state of the present
mission and sub-missions.
First of all, the algorithms necessary for developing this mission will be presented and analyzed. Each subsection of
this section has the next structure: first, different algorithms of this part are going to mention. Then one of these will
be chosen and explained and finally related works will be cited. In the final subsection, the case of use will be
develop with examples of each algorithms.
3.1 Data structures
As it was mentioned in the state of the art, “low level” data structures will be dependent on the different OS and
hardware used in each case. So, efficiently managing the system physical memory and storage drives, and efficiently
storing and retrieving data from them, will be transparent to upper layers of the system architecture.
The OS´s typically work with some kind of directory tree and file managing system in order to abstract this
mechanisms to the user, providing the necessary tools to compile/interpret developed software that efficiently uses
the system capabilities. For example, the Robot Operative System (ROS) project uses a Linux kernel (UNIX i-node
file system) with C++ (and others) as source code of the libraries, providing means to develop and test the software
in many Unix-based platforms [30].
When using SW technologies, the knowledge is represented on last instance with RDF triples (subject-predicate-
object), serialized in RDF files. RDF extend the resource description capabilities of URI incorporating (DL) logic
knowledge to that description. Subject and predicate must be URI resource identifiers, and objects may be an URI or
a literal (plain or typed with XML). A set of triples form a RDF graph, and only subjects or predicates could be
blank in order to be used as graph scoped identifiers (blank nodes). RDF language namespace contains the RDF
vocabulary with several predefined elements to conform the graphs. The elements rdf:statement,
rdf:subject, rdf:predicate and rdf:object, allows to dissemble a statement (triple) to its parts, and to use
that parts or the whole statement as a resource to make assertions about it (e.g. using it as subject in another
statement), composing then nested RDF graphs [31].
RDF triples and graphs conform sets of related logical assertions, so it may be considered just as data rich
descriptors to meta-data for resources (data).
RDF Schema is a semantic extension of RDF vocabulary that allows to describe taxonomies of classes and
properties. In RDF Schema, all resources can be divided into groups called classes (rdfs:class). Classes are also
resources (rdfs:resource), so they are identified by URIs and can be described using properties (rdfs:domain,
rdfs:range, rdfs:subClassOf, rdfs:subPropertyOf, rdfs:member, rdfs:isDefinedBy...). The
members of a class are instances of classes, which is stated using the rdf:type property. Note that class and a set of
instances does not have to be the same. The RDF Schema class and property system is similar to the systems used in
object-oriented programming languages such as Java. RDF Schema differs from them in that instead of defining a
class in terms of the properties its instances may have, RDF Schema describes properties in terms of the classes of

resource to which they apply using rdfs:domain and rdfs:range properties. Using the RDF Schema approach, it is
easy for others to subsequently define additional properties with a specific domain or range. This can be done
without redefining the original description of these classes, allowing anyone to easily extend the description of
existing resources. [31][32]
The RDF Schema strategy is to acknowledge that there are many techniques through which the meaning of classes
and properties can be described. Richer vocabulary or 'ontology' languages such as OWL, inference rule languages
and other formalisms (for example temporal logics) will each contribute to our ability to capture meaningful
generalizations about the data. [32]
RDF files can be serialized using XML, but other less verbose serialization formats are used as well, like TURTLE
and N3. [31]
“Unfortunately, not everything from RDF can be expressed in DL. For example, the classes of classes are not
permitted in the (chosen) DL, and some of the triple expressions would have no sense in DL. That is why OWL can
be only syntactic extension of RDF/RDFS (note that RDFS is both syntactic and semantic extension of RDF). To
partially overcome this problem, and also to allow layering within OWL, three species of OWL are defined”.[31]
OWL is a syntactic extension of RDF/RDF Schema that allows to conform ontologies in order to extract logical-
computable knowledge from RDF/RDFS-based knowledge bases or files. So it may be considered that at this level
the RDF resources taxonomies we can describe with RDF Schema begin to conform knowledge structures more than
simply data-structures.
An example of RDF based on the case of studied is presented in next figure.
Figure 2: Graph RDF and triplet.
Next figure shows an example of RDF-S graph.

Figure 3: Graph RDF and triplet.
3.2 Knowledge Representation Primitives
Our use case will work in/with Ontologies, so the required tools to represent them should be chosen or developed
and work with ontologies in a human-readable way [1].
When explicitly representing knowledge, it helps to assume that it is composed of elemental knowledge pieces
(statements/propositions) like “eAUV1 is a robot”.
An ontology will be a set of this atomic knowledge pieces (that are called axioms in OWL 2). The ontology will
generally confirm if all the axioms on the ontology are true for a certain "state of affairs". That distinguishes them
from entities or expressions that will be further explained.
In our approach, statements in OWL are considered as the KR Primitives, thus they usually are not "monolithic",
and have some subjacent structure, like “eAUV1 is a robot”, there we have an object from the real world and a
category assignation. In the statement “eAUV1 is doing the same mission that eAUV2” we see two object from the
real world and a relation between them. In OWL 2 the objects are called individuals, categories are called classes,
and relations are called properties. Properties are subdivided in Object properties and Datatype properties. All this
atomic elements are called entities.
Entities names could be combined in expressions using constructors, conforming new entities defined by their
structure. Class expressions is one of the main features of OWL 2. [31][33]
“The OWL is a family of knowledge representation languages for authoring ontologies. Ontologies are a formal way
to describe taxonomies and classification networks, essentially defining the structure of knowledge for various
domains: the nouns representing classes of objects and the verbs representing relations between the objects.” [19]

Next figure shows the structure of OWL 2 (OWL 2 is an extension and revision of the OWL published in 2004). The
eclipse in the centre represents the abstract notion of an ontology. At the top are various concrete syntaxes that can
be used to serialize and exchange ontologies. At the bottom are the two semantic specifications that define the
meaning of OWL2 ontologies [10].
Figure 4: The structure of OWL 2 [20]
There are three variants of OWL: OWL Lite, OWL DL and OWL Full (ordered by increasing expressiveness) [20]
[21] [22].
• OWL Lite: it was intended to provide a simple tool support, allowing quick migration path for systems
using thesauri and other taxonomies.
• OWL DL: it was designed to provide the maximum expressiveness possible while retaining computational
completeness decidability, and the availability of practical reasoning algorithms.
• OWL Full: it is based on a different semantics from OWL Lite or OWL DL and was designed to preserve
some compatibility with RDF Schema.
3.2.1 OWL-DL (Deterministic)
OWL DL is an extension of OWL focused on description logics (DL). A DL models concepts, roles and individuals,
and their relationships. The main modelling concept of a DL is the axiom (logical statement which relates roles
and/or concepts) because DL declares and completely defines a class [23].
OWL DL is a subset of FOL (First-Order Logic) and it use its terminology, in spite of being an implementation of a
description logic. Like FOL, a syntax defines which collections of symbols are legal expressions in a DL, and
semantics determine meaning. Unlike FOL, a DL may have a lot of well-known syntactic variants [24].
Modelling knowledge with OWL DL is based in two components: TBox (terminological box) and ABox (assertion
box). TBox is related with the terminology (the vocabulary of an application domain). And ABox relates concepts
described in TBox with individuals.

In the case of Cooperative Robots in dynamic environments, TBox may take the role of an upper ontology symbolic
library used by the whole system. Robots could share easier knowledge, using its own ontologies (or Abox) created
for its individual perception and using his own contextual knowledge.
Some examples of OWL DL applications in collaborative AUVs are:
• Mine Countermeasures (MCM):
“OWL DL provides much of the expressiveness of first-order logic while providing very desirable features such as
soundness, completeness and decidability upon applying reasoning.” [25]
• Project Bückner et al:
“Bückner et al use semantic network for knowledge representation. Also, image processing languages, image token
databases, logic programming languages and description logic systems can be used for KR in image
understanding.” [26]
3.2.2 PR-OWL (Probabilistic)
Other approaches try to join uncertainty and semantics with a probabilistic approach, dealing with the already
mentioned problem of uncertainty or incompleteness of the acquired knowledge. Uncertainty can be considered
ubiquitous, so any KR system intended to model real world processes must be able to deal with it. [27] [28]
Providing means to model uncertainty in ontologies, PR-OWL and PR-OWL 2 are possible solutions for this
problem. They just adds new definitions to current OWL, keeping backward compatibility with it. They use formal
semantics based on Multi Entity Bayesian Networks probabilistic logic MEBN [29], which is a FOL subset with
some add-ons so it combine the expressiveness power of FOL with the inference capabilities and robustness of
probabilistic representations. In essence, this OWL extensions define classes that can be used to represent the
elements needed by a MEBN: random variables, MFrags, MTheories and associated probabilistic distributions [27].
[27] Also enumerate the most important types of incompleteness and uncertainty in the knowledge that an AUV
robot like PANDORA [18] has to deal with:
 Instances incompleteness or uncertainty. Due to sensory limitations the robot e.g. might believe that
certain object described by some ontology is present in some place of the world with certain probability,
nut the uncertainty is only given in the robot “belief” of the world. Assuming the ontology represents the
belief in the world, the uncertainty is only related to the ABox of the ontology, while the TBox might not
have any uncertainty.
 Relations incompleteness or uncertainty. The same problem appears when establishing ontological
relations between context elements grounded into different semantic concepts by sensor processing, again
the uncertainty will be related to the ABox “instances” of some TBox “deterministic class” of the ontology.
 Inferred relations and concepts incompleteness or uncertainty. In this case the uncertainty is given for
the probabilistic inference methods and not by the sensor limitations. However the uncertainty keeps
related only to the ABox physical instances, now generated from some probabilistic rules of the TBox.
 Evolving world uncertainty. Now the uncertainty is not about the world beliefs but about the changing
world itself and it evolution in time. However the system can also naturally evolve into different states with
different probabilities, which will be updated with every given world model “actualization”.
In all this cases PR-OWL offers more effective solutions than other probabilistic-based ontology frameworks like
BayesOWL, which [27] describe as: “not appropriate for domains where probabilities must be associated with
instances in the ontology, for example where there is a requirement to associate an uncertainty with sensor readings.
This effectively rules out BayesOWL for the Pandora project.”

The main drawback when using PR-OWL ontologies is the difficulty of linking the concepts in a given domain
ontology with the ones in a PR-OWL ontology, while BayesOWL could be used with it. However PR-OWL 2 has
considerably improved this aspect [27] [28].
3.3 Querying
Once the ontologies have been chosen, the next choice should focus on which querying algorithms are suited more
to our use case. Queries are one of the things that make databases so powerful. A "query" refers to the action of
retrieving data from your database. Querying algorithms help the system makes a properly data selection to use only
the knowledge it needs.
The main querying algorithm used in Robotics based on semantic web is SPARQL, but in some projects, they have
created their own algorithms. These algorithms were adapted to their specific ontologies and systems. Some
examples of this algorithms are:
 OpenEval:
In Carnegie Mellon University was developed OpenEval, it is a querying algorithm with predicate evaluator
functions. It can return a probability distribution over instances of predicates [34].
 RaQueL (ROBOBRAIN QUERY LIBRARY):
Between Cornell University and Stanford University, RoboBrain was developed as a robot for smart homes,
specially, kitchens. The RoboBrain’s knowledge source is the Internet (such as WordNet, ImageNet, Free-base and
OpenCyc). RaQuel is more than a querying algorithm, RaQueL can be used for diverse tasks such as semantic
labeling, cost functions and features for grasping and manipulation, grounding language, anticipating activities, and
fetching trajectory representations [35].
3.3.1 SPARQL
SPARQL (SPARQL Protocol and RDF Query Language) is defined in [36] as: “an RDF query language, that is, a
semantic query language for databases, able to retrieve and manipulate data stored in Resource Description
Framework format.”
SPARQL contains IRIs (in SPARQL queries are absolute) which are a subset of RDF URI References that omits
spaces and include URIs and URLs [37].
The queries of SPARQL contains a set of triple patterns called a basic graph pattern which are similar to RDF triples
but in this case, each subject, predicate and object may be variable [37].
In SPARQL is used the Turtle data format to show each triple explicitly because Turtle allows IRIs to be abbreviated
with prefixes. A simple example of query in SPARQL is shown below:
The data is presented in Turtles:
@prefix tsk: <localhost:/GLOBAL/KB/term/Task#>
@prefix auv: <localhost:/GLOBAL/KB/term/auv.rdf#>
@prefix : <localhost:/GLOBAL/KB/assert/exampleTask.rdf#>.
:20150101-002 tsk:percentAccomplish “51” ,
:hasMember auv:sauv2 .
The query is:
PREFIX tsk: <localhost:/GLOBAL/KB/term/Task#>
SELECT ?hasMember
WHERE { ?x tsk:percentAccomplish ?percentAccomplish
FILTER (?percentAccomplish > 50)
}

It is a simple query but in the document referenced in [37] there are a lot of examples of different queries in function
of the information that is want to be consult. In the section X an example of Turtles and SPARQL queries will be
shown related with de case of use.
As a resume of [37], SPARQL permits to apply filters (FILTER), optional triples (OPTIONAL) and to make the
FROM part optional. Modifiers of the sequence results are similar to SQL: ORDER BY, DISTINCT, OFFSET and
LIMIT. The allowed queries are four: SELECT (returns variables and their bindings directly), CONSTRUCT
(returns a single RDF graph specified by a graph template), ASK (no information is returned about the possible
query solutions, jus whether or not a solution exists) and DESCRIBE (returns a single result RDF graph containing
RDF data about resources). Formats results supported by SPARQL 1.1 are XML, JSON, CSV and TSV [36]. To
obtain more information the documents referenced in [38], [39] and [40] may be consulted. There are and extension
of the basic SPARQL, referenced in [41] that allow to explicitly delegate certain subqueries to different SPARQL
endpoints. Finally, in the document referenced in [42], it is described the update request for SPARQL.
The SPARQL protocol referenced in [43] consist of two operations: queries and updates. Its works with HTTP
request and responses.
3.4 Rules
Continuing with the definition of the tools and algorithms of our case of use it is necessary to extend the knowledge
system by introducing some Ruling tools defined on W3C, especially in this subsection. It will be focused on RIF
and SWRL.
3.4.1 RIF (Rule Interchange Format)
RIF is “a standard for exchanging rules among Semantic Web systems. RIF focused on exchange rather trying to
develop a single one-fits-all rule language” [44].
This language depends of the paradigms used in each system. A classification has been made based on this problem:
first-order, logic-programming, and action rules. To solve this problem RIF has designed a family of languages,
called dialects. This dialects have been created to be uniform and extensible: uniform because they are expected to
share as much as possible of the existing knowledge system and extensible because developers can define a new
dialect as a syntactic extension to an existing RIF dialect [44].
In the proposed case of use, it is used a data structure based on RDF/S and a representation of ontologies based on
OWL, the most appropriate RIF dialect for our system is the dialect called "RIF-RDF and OWL Compatibility". The
basic idea is that RIF uses its frame syntax to communicate with RDF/OWL. These frames are mapped onto RDF
triples and a joint semantics is defined for the combination [44].
3.4.2 SWRL (Semantic Web Rule Language)
SWRL is “based on a combination of the OWL DL and OWL Lite sublanguages of the OWL Web Ontology
Language with the Unary/Binary Datalog RuleML sublanguages of the Rule Markup Language” [45]. SWRL
extends the set of OWL axioms to include Horn-like rules (FOL-based rules), so it enables Horn-like rules to be
combined with an OWL knowledge base.
Rules are of the form of an implication between an antecedent (body) and consequent (head). The intended meaning
can be read as: whenever the conditions defined in the antecedent hold, then the conditions defined in the
consequent must also hold [45].
The antecedent (body) and consequent (head) consist of zero or more atoms. An empty antecedent is treated as
trivially true, so the consequent must also be satisfied by every interpretation; an empty consequent is treated as

trivially false, so the antecedent must also not be satisfied by any interpretation. Multiple atoms are treated as a
conjunction [45].
In the proposed case of use, we need to extend the expressivity of OWL by adding SWRL rules to our ontology
because OWL is not able to express all relations. For example, OWL cannot express the relation of a task with the
submissions which compose a general mission, because there is no way in OWL to express the relation between
individuals with which an individual has relations [46].
An example of rules is shown in next figure.
Figure 5: Graph
Figure 6: Rules
Declaration(Class(:iAUV))
Declaration(ObjectProperty(:hasMaster))
Declaration(Class(:AUV))
Declaration(Class(:Agent))
SubClassOf(:iAUV :AUV)
SubClassOf(:Master :AUV)
Declaration(DataProperty(:tsk:percentAccomplish))
Declaration(NamedIndividual(:eAUV1))
ClassAssertion(:eAUV : eAUV1)
DataPropertyAssertion(:tsk:percentAccomplish “51”^^xsd:integer)
Declaration(NamedIndividual(:eAUV2))
ClassAssertion(:eAUV : eAUV2)
Declaration(NamedIndividual(:iAUV3))
ClassAssertion(:iAUV : iAUV3)
ObjectPropertyAssertion(:hasMaster : eAUV1: iAUV3)
ObjectPropertyAssertion(:hasMaster : eAUV2: iAUV3)

3.5 Reasoning
This subsection provides a comparison between semantic web reasoners. “A reasoner is a program that infers
logical consequences from a set of explicitly asserted facts or axioms and typically provides automated support for
reasoning tasks such as classification, debugging and querying” [47]. To choose a suitable reasoner it is necessary
to analyse each dimension of reasoners. First, the underlying reasoning characteristics for example, the method of
reasoning, the expressivity, rules and so on. Next dimension is practical usability: if the reasoner implements OWL,
if it is commercial or Open Source, the platforms where it runs and, in our case, if it is available as Protègè plugin.
Last dimension is about performance indicators that can be evaluated empirically (for example classification). [47]
Next table shows a brief comparison between three reasoners: FaCT++, HermiT and Pellet.
Table 1: Reasoners Comparison [47]
FaCT++ HermiT Pellet
Completeness Yes Yes Yes
Expressivity SROIQ(D) SROIQ(D) SROIQ(D)
Incremental
Classification
(additional/removal)
No/No No/No Yes/Yes
Rule support No Yes (SWRL) Yes (SWRL)
Justifications No No Yes
ABox Reasoning Yes Yes Yes (SPARQL)
OWL/ OWLlink API Yes Yes Yes
Protègè Plugin Yes Yes Yes
License GLGPL GLGPL GLGPL
Open Source Yes Yes Yes
Language C++ Java Java
Platforms All All All
In the case of use is used the Pellet reasoner because it supports SWRL rules and SPARQL which are the necessary
characterises.
4. KR&R algorithms
In this section current approaches will be describe and next step goals in the robotic field related to KRR systems.
So that some current approaches are mentioned and are linking with its possible application in our case of study.
Handling incompleteness and inconsistency:
As previously mentioned, handling incompleteness in knowledge representation can be partially solved by using
some probabilistic approach like PR-OWL extension. Therefore, any OWL inference engine with PR-OWL syntax
compatibility should be able to reason about that knowledge, producing results that may be expressed with the help
of that syntax too. Anyway, the problematic of handling incompleteness and inconsistency goes further: the KR&R
System should be able, not only to express knowledge with some uncertainty degree in its atomic elements, but to
detect and fix inconsistencies between previously stored and inferred knowledge and the new one (acquired by other
means than reasoning).
Previously it was mentioned too that world model "actualizations" are needed in order to handle Evolving World
Uncertainty, and that the system will evolve into different states with each given actualization of the world model;
this is possible, and relational data-base systems used on the backbone of the proposed system solve all the
consistency problems associated to this. But, with probabilistic approaches and due to the mentioned "state changes"

of the system when updating the world model, some other kind of inconsistencies emerge between knowledge
inferred in some previously states, and knowledge inferred from the same statements in their actual state.
As the system may consider them as representations of different real world objects, even when they were inferred
from the same statements (but with different uncertainty degrees), they could coexists in the knowledge base without
problems, so detecting and fixing this partial inconsistencies should be periodically and atomically done by some
parallel processes or agents which will somehow interact with the knowledge base. This process is called belief
revision.
In order to achieve this, negation as failure operator, statement removal, default declarations and exceptions
declarations are all needed. But FOL (and so DL) are essentially monotonic logics, in the sense that anything that
could be concluded before a clause is added can still be concluded after it is added, so it is impossible to achieve this
only with DL. [48]
On the other hand we don´t have the same problem with rule-sets, that, in the proposed use case, will be expressed
with the Semantic Web Rule Language. There is no point in applying a rule to a randomly chosen individual rather
than to specific ones (like it is done when applying generic probabilistic knowledge [49]).
In the next section, some different approaches to solve the non-monotonic reasoning problem and other architecture
problems associated to the inference engine will be presented, and with the help of this approaches, handling
incompleteness and inconsistency problems should be partially solved too.
Non-monotonic reasoning:
Non monotonic reasoning refers to the act of reason about knowledge expressed in some non-monotonic logic. Non-
monotonic logics are formal logics whose consequent relation is non monotonic, that means that reasoners can draw
tentative conclusions in what is called defeasible inferences, and later could retract that conclusions based on further
evidence [50]. A monotonic logic cannot handle belief revision and some other reasoning task such as reasoning by
default, inductive reasoning or abductive reasoning.
Non monotonic logics use implies a closed-world assumption.
Some other defeasible reasoning types are statistical, probabilistic and paraconsistent logic reasoning [51].
In the present approach, the proposed global KR&R System must provide means to reason about knowledge
expressed in probabilistic terms with some OWL inference engine. One way to achieve this, is by using some
extension or variation of the used inference engine that allows it to reason with PR-OWL ontologies. Some works
have been developed in this direction. For example, "Pronto" is a probabilistic OWL reasoner that can handle
uncertainty in both terminological and assertional DL statements (axioms), it extends the Pellet inference engine
making it capable to do default probabilistic reasoning. A deeper analysis of the Pronto prototype could be found on
[52].
Other approaches to solve the problem of non-monotonic reasoning in systems based on DL ontologies like [52]
tries to divide the problem by using two inference engines for various different "contexts", one context will be the
DL ontology-based KR&R system, and the other one will be some non-monotonic logic programming rules context
(MKNF knowledge bases in this case). Both context interact with something called "bridge rules", that is just some
set of rules that project logical propositions from one set to another. This is called a Multi Context System (MCS),
and they provide a way to integrate knowledge generated from different sources and reason about it with some DL
inference engine.
MCS´s could be a perfectly suited solution not only to integrate different monotonic and non-monotonic logics in
the same AUV, but to integrate other needed knowledge and routines like:
- Static real world objects models: mission plans, maps etc...
- Models of the AUV itself (meta-representation).
- Belief revision and other knowledge base "maintenance" routines.
- Other AUV function-related process and/or algorithms.
- Many more...

MCS´s could make the knowledge generated by all them suitable to the OWL inference engine "translating" it into
DL. Inference engine could then reason about that knowledge and make the knowledge produced by it readable to
the other contexts [53].
To summarize, the KRR system that is proposed could use Pellet inference engine with the Pronto extension to
handle with some problems that have been exposed. Although, it could benefit from using MCS not only with this
problems but to do all its components being well integrate with all the others one.
5. Conclusions
In our case of use the task of coordinating a mission between collaborative AUV can be improved an eased by using
a global KR&R system. This system is independent of each individual cognitive architecture and enhance mission-
related knowledge sharing. So that, the efficiency of the synchronized-mission execution is improved.
Using Semantic Web technologies eased the process of developing the structure of the knowledge system.
Non-monotonic logic inclusion in the inference engine rules and knowledge representation primitives could solve
inconsistency problems, for example with “belief-revision”. And thanks to the use of MCS (Multi-Context Systems)
it could be possible to make completely independent the character of the set of rules used in the proposed KR&R
system.
Other reason to use non-monotonic logic is the capacity of representing and reasoning about knowledge in
probabilistic terms.
6. Future Work
First, to check the advantages of the proposed KR&R system when the case of study involves coordinating a large
number of AUVs and task, more complex missions, and different contexts of MCS.
Second, to study further and experience how PR-OWL and other probabilistic approaches KR&R can improve the
functioning of the proposed system.
And at least but not the less important, to implement non-monotonic logical contexts in any of the system as, for
example, modules “belief-revision”. To implement non-monotonic logic in the set of rules so that judgments can be
removed from the knowledge base.
Acknowledgements
The authors would like to thank all the class-mates of ATA and our teacher JF. Also, to thank Gregorio Rubio for his
advice.

References
[1] SPARC, «Robotics 2020 Multi-Annual Roadmap» 06 February 2015. [Online]. Retrieved 15 March 2015.
Available: http://www.eu-robotics.net/cms/upload/PDF/Multi-
Annual_Roadmap_2020_Call_1_Initial_Release.pdf.
[2] S. R. H. L. Chun-Yi Su, Intelligent Robotics and Applications, 5th International Conference, ICIRA 2012,
Montreal, QC, Canada: Springer, 2012.
[3] R. Davis, H. Shrobe and P. Szolovits, “What is a Knowledge Representation?,” AI Magazine, vol. 14, no.
1, pp. 17-33, 1993.
[4] Knublauch, Holger; Oberle, Daniel; Tetlow, Phil; Evan 09 March 2006. "A Semantic Web Primer for
Object-Oriented Software Developers". W3C.
[5]. Wikipedia contributors. “General Problem Solver”. Wikipedia, The Free Encyclopedia, 16 March 2015.
Retrieved 15 March 2015. [Online]. Available:
http://en.wikipedia.org/w/index.php?title=General_Problem_Solver&oldid=599871187
[6] Russell, Stuart; Norvig, Peter (1995). Artificial Intelligence: A Modern Approach. Simon & Schuster. pp.
22–23. ISBN 0-13-103805-2.
[7] Wikipedia contributors. "Expert system." Wikipedia, The Free Encyclopedia., 16 March 2015. Retrieved 15
March 2015. [Online]. Available:
http://en.wikipedia.org/w/index.php?title=Expert_system&oldid=651655828
[8] Wikipedia contributors. “Knowledge Engineering Environment”. Wikipedia, The Free Encyclopedia. 14
March 2015. Retrieved 15 March 2015. [Online]. Available:
http://en.wikipedia.org/w/index.php?title=Knowledge_Engineering_Environment&oldid=651351502
[9] Berners-Lee, Tim; James Hendler and Ora Lassila (May 17, 2001). "The Semantic Web A new form of
Web content that is meaningful to computers will unleash a revolution of new possibilities". Scientific
American.
[10] W3C, «OWL 2 Web Ontology Language Document Overview (Second Edition),» 11 December 2012.
[Online]. Available: http://www.w3.org/TR/owl2-overview/. [Last access: 11 March 2015].
[11] Grounding Robot Sensory and Symbolic Information Using the Semantic Web Christopher Stanton and
Mary-Anne Williams Innovation and Technology Research Laboratory, Faculty of Information Technology
University of Technology, Sydney, Australia
[12] Efficient Multi-AUV Cooperation using Semantic Knowledge Representation for Underwater
Archaeology Missions Nikolaos Tsiogkas, Georgios Papadimitriou, Zeyn Saigol, David Lane Ocean Systems
Laboratory Heriot Watt University, EH14 4AS Edinburgh, Scotland, UK
[13] Semantic Approach to Dynamic Coordination in Autonomous Systems Artem Katasonov and Vagan
Terziyan University of Jyväskylä, Finland artem.katasonov@jyu.fi, vagan@jyu.
[14] Claire D’Este, Ahsan Morshed, and Ritaban Dutta, Castray Esplanade, Hobart, TAS Australia. CSIRO
Computational Informatics. Robot Sensor Data Interoperability and Tasking with Semantic Technologies.
[15] A. Elgi, and B. Rahnama Department of Computer Engineering, and Internet Technologies Research
Center, Eastern Mediterranean University, Gazimagusa, Mersin 10, TRNC, Turkey. Human-Robot Interactive
Communication Using Semantic Web Tech in Design and Implementation of Collaboratively Working Robot.
[16] Francesco Maurelli, Zeyn Saigol, Carlos C. Insaurralde, Yvan R. Petillot, David M. Lane Ocean Systems
Laboratory School of Engineering & Physical Sciences Heriot-Watt University EH14 4AS Edinburgh. Marine
world representation and acoustic communication: challenges for multi-robot collaboration.
[17] Interactive And Robotic Systems lab 7 March 2015 [Onine]. Available:
http://www.irs.uji.es/project/trident-eu-fp7-project
[18] Pandora, Persistent Autonomous Robots. 7 March 2015 [Online]. Available:
http://persistentautonomy.com/
[19] W. contributors, “Web Ontology Language,” 7 March 2015. [Online]. Available:
http://en.wikipedia.org/w/index.php?title=Web_Ontology_Language&oldid=650337140. [Accessed 11 March
2015]
[20] W3C, «OWL 2 Web Ontology Language Document Overview (Second Edition),» 11 December 2012.

[Online]. Available: http://www.w3.org/TR/owl2-overview/. [Last access: 11 March 2015]
[21] W3C, «OWL Web Ontology Language Guide,» 10 February 2004. [Online]. Available:
http://www.w3.org/TR/owl-guide/. [Last access: 11 March 2015].
[22] W3C, «OWL Web Ontology Language Reference,» 10 February 2004. [Online]. Available:
http://www.w3.org/TR/owl-ref/. [Last access: 11 March 2015].
[23] Grau, B. C.;Horrocks, I.; Motik, B.; Parsia, B.; Patel-Schneider, P. F.; Sattler, U. (2008)."OWL 2: The
next step for OWL". Web Semantics: Science, Services and Agents on the World Wide Web 6 (4): 309–
322.doi:10.1016/j.websem.2008.05.001
[24] Ian Horrocks and Ulrike Sattler Ontology Reasoning in the SHOQ(D) Description Logic, in Proceedings
of the Seventeenth International Joint Conference on Artificial Intelligence, 2001.
[25] Papadimitriou, G., Ocean Syst. Lab., Heriot-Watt Univ., Edinburgh, UK, Lane, D. Semantic Based
Knowledge Representation and Adaptive Mission Planning for MCM Missions using AUVs
[26] Gaopan Huang, Integrated Inf. Syst. Res. Center, CASIA, Beijing, China, Yuan Tian ; Guanqing Chang A
Knowledge Representation Architecture for Remote Sensing Image Understanding Systems.
[27] F. Maurelli, Z. A. Saigol, G. Papadimitriou, T. Larkworthy, V. De Carolis, D.M. Lane Ocean Systems
Laboratory School of Engineering & Physical Sciences Heriot-Watt University EH14 4AS Edinburgh.
Probabilistic Approaches in Ontologies: Joining Semantics and Uncertainty for AUV Persistent Autonomy.
[28] Kathryn Blackmond Laskey, Richard Haberlin, Paulo Costa Volgenau School of Engineering George
Mason University Fairfax, VA USA Rommel Novaes Carvalho Brazilian Office of the Comptroller General
Brasília, Brazil. PR-OWL 2 Case Study: A Maritime Domain Probabilistic Ontology
[29] Bases Kathryn Blackmond Laskey Department of Systems Engineering and Operations Research MS4A6
George Mason University Fairfax, VA 22030, USA. MEBN: A Language for First-Order Bayesian Knowledge
[30] ROS.org, «Introduction to Ontologies and Semantic Web» 22 May 2014. [Online]. Available:
http://wiki.ros.org/ROS/Introduction. [Last access: 15 April 2015]
[31] Obitko.com, «ROS/Introduction» 2007. [Online]. Available: http://www.obitko.com/tutorials/ontologies-
semantic-web/. [Last access: 15 April 2015]
[32] W3C, «RDF Schema 1.1» 25 February 2014. [Online]. Available: http://www.w3.org/TR/rdf-schema/.
[Last access: 15 April 2015]
[33] W3C, «OWL 2 Web Ontology Language Primer (Second Edition)» 11 December 2012. [Online].
Available: http://www.w3.org/TR/2012/REC-owl2-primer-20121211/. [Last access: 15 April 2015]
[34]. Thomas Kollar, Mehdi Samadi, Manuela Veloso, School of Computer Science, Carnegie Mellon
University. Enabling Robots to Find and Fetch Objects by Querying the Web.
[35] Ashutosh Saxena, Ashesh Jain, Ozan Sener, Aditya Jami, Dipendra K Misra, Hema S Koppula.
Department of Computer Science, Cornell University and Stanford University. RoboBrain: Large-Scale
Knowledge Engine for Robots.
[36] W3C, «SPARQL 1.1 Overview» 21 March 2013. [Online]. Available: http://www.w3.org/TR/sparql11-
overview/. [Last access: 15 April 2015]
[37] W3C, «SPARQL Query Language for RDF» 15 January 2008. [Online]. Available:
http://www.w3.org/TR/rdf-sparql-query/. [Last access: 15 April 2015]
[38] W3C, «SPARQL Query Results XML Format (Second Edition)» 21 March 2013. [Online]. Available:
http://www.w3.org/TR/rdf-sparql-XMLres/. [Last access: 15 April 2015]
[39] W3C, «SPARQL 1.1 Query Results JSON Format» 21 March 2013. [Online]. Available:
http://www.w3.org/TR/sparql11-results-json/ .[ Last access: 15 April 2015]
[40] W3C, «SPARQL 1.1 Query Results CSV and TSV Formats» 21 March 2013. [Online]. Available:
http://www.w3.org/TR/sparql11-results-csv-tsv/. [Last access: 15 April 2015]
[41] W3C, «SPARQL 1.1 Federated Query» 21 March 2013. [Online]. Available:
http://www.w3.org/TR/sparql11-federated-query/. [Last access: 15 April 2015]
[42] W3C, «SPARQL 1.1 Update» 21 March 2013. [Online]. Available: http://www.w3.org/TR/sparql11-
update/. [Last access: 15 April 2015]
[43] W3C, «SPARQL 1.1 Protocol» 21 March 2013. [Online]. Available: http://www.w3.org/TR/sparql11-
protocol/. [Last access: 15 April 2015]
[44] W3C, «RIF Overview» 5 February 2013. [Online]. Available: http://www.w3.org/TR/rif-overview/. [Last

access: 15 April 2015]
[45] W3C, «SWRL: A Semantic Web Rule Language» 21 May 2014. [Online]. Available:
http://www.w3.org/Submission/SWRL/. [Last access: 15 April 2015]
[46] Masaryk University, «OWL 2 and SWRL Tutorial» 21 May 2014. [Online]. Available:
http://dior.ics.muni.cz/~makub/owl/#swrl [Last Access: 15 April 2015]
[47] Kathrin Dentler, Ronald Cornet, Annete ten Teije and Nicolette de Keizer. Comparison of Reasoners for
large Ontologies in the OWL 2 EL Profile. 2011. [Online]. Available: http://www.semantic-web-
journal.net/sites/default/files/swj120_2.pdf
[48] David Poole and Alan Mackworth. Non-monotonic Reasoning. 2010. [Online]. Available:
http://artint.info/html/ArtInt_129.html
[49] Ngoc-Tung Nguyen. [Online]. http://gicl.cs.drexel.edu/images/c/cf/NNguyenPronto-
LexicographicEntailmentSlides.pdf
[50] Wikipedia Contributors. Non-monotonic logic. (2015, April 8). In Wikipedia, The Free Encyclopedia.
Retrieved 21:53, April 29, 2015, from http://en.wikipedia.org/w/index.php?title=Non-
monotonic_logic&oldid=655478606
[51] Wikipedia contributors. "Defeasible reasoning." Wikipedia, The Free Encyclopedia. Wikipedia, The Free
Encyclopedia [Online], 23 Apr. 2015. [Last access: 9 May. 2015].
[52] Pavel Klinov, Bijan Parsia. Demonstrating Pronto: a Non-Monotonic Probabilistic OWL Reasoner.
P. Klinov1, B. Parsia1. The University of Manchester, Manchester, M13 9PL, UK
[53] Martin Homola, Matthias Knorr, Joao Leite, and Martin Slota [Online]. Available:
http://dai.fmph.uniba.sk/~homola/papers/clima2012.pdf

G9_Cognition-Knowledge Rep and Reas_H6

Recommended

Recommended

More Related Content

What's hot

What's hot (13)

Similar to G9_Cognition-Knowledge Rep and Reas_H6

Similar to G9_Cognition-Knowledge Rep and Reas_H6 (20)

G9_Cognition-Knowledge Rep and Reas_H6