Embedding Matrices Ontology into Math Software
Engines to Support Reasoning and Mission Oriented
Calculation in Developing Semantic Agents
A. Elçi, B. Rahnama, and K. Bahreini
Dept. of Computer Engineering, and Internet Technologies Research Center, Eastern Mediterranean University, Famagusta, Turkey
{atilla.elci, behnam.rahnama, kiavash.bahreini}@emu.edu.tr
Abstract–The Semantic Web Technologies (SWTs) are utilized
in different areas of research as a tool to represent meaningful
and inferable data. Yet researchers try to come up with standardization for usage of SWTs to be able to apply it in various fields.
However, the current implementations are very specialized to
task and are not flexible for different instances. In this paper, we
focus on design and implementation of an interface between
matrix data structures utilized in various mathematical software
and OWL ontology files. Therefore, ontology files can be
embedded into math software for reasoning and calculation
purposes. Moreover, the result of math software can be
represented in form of ontology files. This issue resolves the lack
of math engines to work with semantic web services. In this case a
new framework for real-time human interactive communication
and semantic software agents are proposed. The representation of
traffic network as labyrinth into ontology files helps other
information systems to interact much easier. This representation
is in terms of an optimized adjacency matrix. As result, the realtime system can detect an ambulance and flow the traffic in such
a way that it reaches the nearest hospital much faster. Hence, the
labyrinth data should be transformed to an optimized matrix for
labyrinth discovery software agents to respond user interactive
queries such as finding the best path to an accident for traffic
police officers. In this framework, collecting the Drivers’
identities and also passengers with use of RFID tags as a part of
their ID cards is possible. These data could be used for statistics
purposes. The results of the developed system have been tested on
cooperative labyrinth discovery agents with great achievements.
I. INTRODUCTION
Aiming to build a framework for design and implementation
of real-time semantic agents [1], [6] needs specific base
modules to work and result individually. These multi module
structures should work as independent as possible to be run in
parallel and result a better outcome for developing semantic
multi agents[3], [4]. Unfortunately, such a framework does not
exist yet to remedy such difficulties. One of these bases which
play an important role is math software engines that can handle
a lot of calculations much faster and much easier. Nevertheless, there is no standard bridge between semantic web
technology data representations and math engines [9]. This gap
can be covered by embedding matrices ontology into math
software engines to support reasoning and mission oriented
calculations. On the other hand, software and human interactive communication requires ease of use and semantic data
understanding for machines and software robots which
basically utilize mathematic formulas and data structures to
solve human queries [5], [7]. This research focus on design
and implementation of embedding semantic data representatives into math software engines as one of the bases of
futuristic design of such mentioned framework. The following
section demonstrates instances of semantic data representations in matrix form. Consequent sections provide a scheme
for such presentation. Then a test case is mentioned to measure
the implemented scheme. Finally we conclude the paper by
showing the obtained results.
II. INSTANCES OF REPRESENTATION AND OPTIMIZATION OF
MATRICES IN COOPERATIVE SEMANTIC AGENTS
SYSTEMS
The Traffic Management and Information System (TMIS) is
a platform where semantic mobile agents collaborating with
each other to balance the traffic and also help an ambulance to
find the shortest possible path to hospital or providing the
fastest path to firefighters to reach their destination without
letting people understand these issues [2]. Such cars can be
easily recognized by traffic junctions using RFID tags
embedded in body of the car [8]. We can easily imagine that
the traffic system is like a directed graph which can be
represented using adjacency matrices. Therefore by having
such representation, queries can be solved much faster while a
lot of formulas for graphs using matrices exist. However
adjacency matrices are suffered from data redundancy, lack of
loop representation, and defining the edge names. It is required
to be improved and optimized to work more efficiently with
reasoning engines.
Finding the shortest possible path for an ambulance in traffic
network is almost like cooperative labyrinth discovery robots
finding a way out of very large maze. Conversely the mobile
robots are fixed at junctions and cars are passing through the
junctions. Such data can be represented as maze matrices. But
these matrices require optimization whereas redundant
elements such as walls at intersection of two block of maze are
kept extra. More detail on this optimization is given as follows:
The Cooperative Labyrinth Discovery Robots (CLDs) [9]
trace the maze partially and share the results of the traversed
sub-sets as shortest path and path to exit with other CLD
robots. However CLD suffer from controlling data redundancy
in maze set data structure whereas each wall is shared between
two neighboring blocks. Correspondingly memory usage
which has important bearing in microcontroller programming
In Proc. The 2008 International Conference on Semantic Web and Web Services (SWWS'08), of the 2008 World Congress in
Computer Science, Computer Engineering, and Applied Computing (WORLDCOMP'08), July 14-17, 2008, Las Vegas, USA.
would not be efficient. In order to avoid storing redundant
data, we have come up with a set of mapping functions to
store/retrieve preferred walled/non-walled edges. In this case
the maze is stored as a set of a matrix of non-redundant edges
and a matrix of blocks’ properties.
The maze set consists of a table of blocks bounded by 4
edges. Therefore, it can be represented as a structure including
the block properties such as number of visits and 4 different
Boolean variables for edges, say “true” or “1” if walled. Hence
each wall except maze boundaries is shared between two
blocks, updating its value in run-time requires a transaction
containing two updates. Consequently, the data structure
contains repeated elements. The space needed for such a
representation is (4 + 1)n 2 for a n × n maze set, where each
edge and property element consumes 1 unit of memory.
Instead, we define a 2n × (n + 1) matrix for walls of a
n × n size.
Correspondingly,
matrix
with
for ∀i, j | 1 ≤ i, j ≤ n , four different walls of a cell are
retrieved as follows:
(left ) ⇒ (i, j )
(right ) ⇒ (i, j + 1)
(up ) ⇒ ( j + n, i )
(down) ⇒ ( j + n, i + 1)
(1)
And we need a n × n size matrix for blocks properties.
Figure below demonstrates an example on 3× 3 maze set as
6× 4 size matrix.
4, 1
5, 1
6, 1
1, 1
1, 2
4, 2
1, 3
5, 2
1, 4
6, 2
2, 1
2, 2
4, 3
2, 3
5, 3
2, 4
6, 3
3, 1
3, 2
4, 4
3, 3
5, 4
3, 4
6, 4
Fig.1. Representation of
n×n
maze as
2n × (n + 1)
(
)
2n 2 + 2n − n 2 + 2n + 1
n + n + 2n − n − 2n − 1
2
2
2
⇒ ∀(n > 1), n 2 − 1 > 0
(4)
III. ONTOLOGY REPRESENTATION OF MATRICES
Such matrices presented above can be shown as OWL
ontology files based on following constraints.
• A Matrix may consist of more than two dimensions.
Therefore, the engine should dynamically allocate proper
space for such matrix. Additionally, nested loops for filling
the values to proper places of matrix should be developed in
run-time. Therefore, we designed an algorithm to provide
nested loops for any n dimensional matrix in O(n log n)
instead of O(2n).
• Row and column operation should be easily applied.
And each two individual elements of a matrix are independent to each other. Due to the structure of the implemented
output files. There is no dependent tag. Hence the above
requirements are satisfied.
The program was implemented in J Builder 2006 with JDK
1.6.0 environment. The reason of selecting Java as implementation language was its compatibility with other semantic web
software and also issues such as platform independence.
The sample program asks user the name of the matrix, its
type, number of dimensions, and also the value for each
dimension. Then, it generates a dynamic data structure for
input values of matrix cells. Then it converts the user input
data in terms of OWL ontology file. The order of cell representation is based on the indices. First index; then second index
and so on, such as first row then column and then depth. The
following screenshots represents the program run-time. Note
that usually matrices exist or it is imported from math
software. Therefore this step is not always utilized.
matrix
A more optimized solution is to keep corners (nodes) as
block representatives. Therefore each edge is noted in an
2
adjacency matrix of (n + 1) size. Moreover there is no limit in
dimension and shape of maze set due to the applied mesh data
structure.
As a result, the space used for representation of maze set in
terms of blocks, edges, and corners are as follows:
{
}
∀ (n > 1 ), 4 n 2 > 2 n 2 + 2 n > n 2 + 2 n + 1
(2)
Fig.2. Entering values for creating a 2 by 3 by 4 matrix
Then the result of the program is an OWL file as follows.
Proof:
(
4n 2 − 2n 2 + 2 n
)
2n + 2 n − 2n − 2n
2
2
2
⇒ ∀(n > 1),2n − 2n > 0
2
(3)
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF[<!ENTITY xsd
"http://www.w3.org/2001/XMLSchema#">]>
<rdf:RDF
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdfsyntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdfschema#"
xmlns="http://www.matrixConversion.com/arrayont#"
xml:base="http://www.matrixConversion.com/arra
y-ont#"
>
<owl:Ontology rdf:about="">
<rdfs:label>Matrix conversion</rdfs:label>
<rdfs:comment></rdfs:comment>
<owl:versionInfo>$Id:matrixConversionont.owl,v 1.0 Sat Apr 19 01:37:10 EEST 2007
Exp$</owl:versionInfo>
</owl:Ontology>
<MatrixDimensions rdf:ID="MatrixDimensions">
<hasValue
rdf:datatype="&xsd;string">3</hasValue>
</MatrixDimensions>
<MatrixType rdf:ID="MatrixType">
<hasValue
rdf:datatype="&xsd;string">float</hasValue>
</MatrixType>
<MatrixName rdf:ID="MatrixName">
<hasValue
rdf:datatype="&xsd;string">MyArray</hasValue>
</MatrixName>
<MatrixDim rdf:ID="MatrixDim">
<hasValue
rdf:datatype="&xsd;string">2,3,4</hasValue>
</MatrixDim>
<MatrixIndexes rdf:ID="MatrixIndexes">
<Index[0,0,0]
rdf:datatype="&xsd;string">3.2</Index[0,0,0]>
<Index[0,0,1]
rdf:datatype="&xsd;string">5.7</Index[0,0,1]>
<Index[0,0,2]
rdf:datatype="&xsd;string">90.45</Index[0,0,2]
>
<Index[0,0,3]
rdf:datatype="&xsd;string">32.5</Index[0,0,3]>
<Index[0,1,0] rdf:datatype="&xsd;string">2.2</Index[0,1,0]>
<Index[0,1,1]
rdf:datatype="&xsd;string">7.7</Index[0,1,1]>
<Index[0,1,2] rdf:datatype="&xsd;string">4.3</Index[0,1,2]>
<Index[0,1,3]
rdf:datatype="&xsd;string">6.0</Index[0,1,3]>
<Index[0,2,0]
rdf:datatype="&xsd;string">5.1</Index[0,2,0]>
<Index[0,2,1]
rdf:datatype="&xsd;string">7.4</Index[0,2,1]>
<Index[0,2,2]
rdf:datatype="&xsd;string">8.9</Index[0,2,2]>
<Index[0,2,3]
rdf:datatype="&xsd;string">0.3</Index[0,2,3]>
<Index[1,0,0] rdf:datatype="&xsd;string">6.7</Index[1,0,0]>
<Index[1,0,1]
rdf:datatype="&xsd;string">90.2</Index[1,0,1]>
<Index[1,0,2]
rdf:datatype="&xsd;string">5.1</Index[1,0,2]>
<Index[1,0,3]
rdf:datatype="&xsd;string">7.8</Index[1,0,3]>
<Index[1,1,0]
rdf:datatype="&xsd;string">8.2</Index[1,1,0]>
<Index[1,1,1]
rdf:datatype="&xsd;string">4.4</Index[1,1,1]>
<Index[1,1,2] rdf:datatype="&xsd;string">23.2</Index[1,1,2]>
<Index[1,1,3]
rdf:datatype="&xsd;string">6.3</Index[1,1,3]>
<Index[1,2,0]
rdf:datatype="&xsd;string">5.5</Index[1,2,0]>
<Index[1,2,1] rdf:datatype="&xsd;string">3.0</Index[1,2,1]>
<Index[1,2,2]
rdf:datatype="&xsd;string">7.0</Index[1,2,2]>
<Index[1,2,3]
rdf:datatype="&xsd;string">80.3</Index[1,2,3]>
</rdf:RDF>
Fig. 3. Entering values in matrix cells
IV. EMBEDDING THE MATRIX ONTOLOGY IN MATH
SOFTWARE
Math software generally support matrices represented as C
data structures. Moreover, other keywords can be represented
with the convertor module to be suitable for specific math
software. At this step the same matrix which already is in
terms of OWL ontology file will be converted to programming
language syntaxes to be useful for math software.
At this part a simple and tiny program converts the above
OWL file into .m and .c files for MATLAB and C compilers.
The following output is generated using the given OWL file
for MATLAB. Note that in MATLAB the indices start from 1
by default.
MyArray=zeros(2,3,4);
MyArray(1,1,1)=3.2;
MyArray(1,1,2)=5.7;
MyArray(1,1,3)=90.45;
MyArray(1,1,4)=32.5;
MyArray(1,2,1)=-2.2;
MyArray(1,2,2)=7.7;
MyArray(1,2,3)=-4.3;
MyArray(1,2,4)=6.0;
MyArray(1,3,1)=5.1;
MyArray(1,3,2)=7.4;
MyArray(1,3,3)=8.9;
MyArray(1,3,4)=0.3;
MyArray(2,1,1)=-6.7;
MyArray(2,1,2)=90.2;
MyArray(2,1,3)=5.1;
MyArray(2,1,4)=7.8;
MyArray(2,2,1)=8.2;
MyArray(2,2,2)=4.4;
MyArray(2,2,3)=-23.2;
MyArray(2,2,4)=6.3;
MyArray(2,3,1)=5.5;
MyArray(2,3,2)=-3.0;
MyArray(2,3,3)=7.0;
MyArray(2,3,4)=80.3;
Additionally for C:
void main(void){
float MyArray [2][3][4];
MyArray[0][0][0]=3.2;
MyArray[0][0][1]=5.7;
MyArray[0][0][2]=90.45;
MyArray[0][0][3]=32.5;
MyArray[0][1][0]=-2.2;
MyArray[0][1][1]=7.7;
MyArray[0][1][2]=-4.3;
MyArray[0][1][3]=6.0;
MyArray[0][2][0]=5.1;
MyArray[0][2][1]=7.4;
MyArray[0][2][2]=8.9;
MyArray[0][2][3]=0.3;
MyArray[1][0][0]=-6.7;
MyArray[1][0][1]=90.2;
MyArray[1][0][2]=5.1;
MyArray[1][0][3]=7.8;
MyArray[1][1][0]=8.2;
MyArray[1][1][1]=4.4;
MyArray[1][1][2]=-23.2;
MyArray[1][1][3]=6.3;
MyArray[1][2][0]=5.5;
MyArray[1][2][1]=-3.0;
MyArray[1][2][2]=7.0;
MyArray[1][2][3]=80.3;
}
V. TESTING THE DEVELOPED SCHEME
Solving the mathematical queries in math software requires
some change in matrix. Therefore a reverse mechanism is also
required to prepare output from matrices represented in a
MATLAB file as OWL ontology file. The result was successful using a very simple convertor we developed.
A case study for the developed scheme is presenting a
sample map showing the traffic network among a few
junctions. The created ontology file can be optimized for
redundancy reduction and then it can be represented as
programming languages syntaxes suitable for math software to
satisfy a query such as shortest path between two node using
intersection nodes.
VI. CONCLUSIONS
In this paper we presented embedding matrices ontology
into math software engines to support reasoning and mission
oriented calculation. This is used as base of developing a
framework for in developing real-time semantic agents and
human interactive communication. The way of representation
of traffic network data and labyrinth matrix and its optimization for being represented in term of ontology data were
covered. Moreover, the ontology data was represented in form
of programming language data structure to be embedded into
math software.
Within this scope, future researches will be developing other
bases for the mentioned framework such as prolog data and
UML information representation as OWL ontology files.
REFERENCES
[1] Elçi and B. Rahnama; Considerations on a New Software
Architecture for Distributed Environments Using Autonomous
Semantic Agents, Proc. 2nd International Workshop on Software
Cybernetics IWSC2005, 29th IEEE COMPSAC 2005, IEEE publications, pp.133-138.
[2] Elçi and B. Rahnama; Intelligent Junction: Improving the
Quality of Life for Mobile Citizens through better Traffic Management, Proc. YvKB 2006, 8-9 June 2006, Ankara, Turkey, TBD
Publications (in Turkish).
[3] H. Takahashi; H. Nishi; K. Ohnishi; Autonomous decentralized
control for formation of multiple mobile robots considering ability of robot, IEEE Transactions on Industrial Electronics, Vol.
51(6), Dec. 2004 pp.1272-1279.
[4] Chia-How Lin; Kai-Tai Song; G.T. Anderson; Agent-based robot
control design for multi-robot cooperation, Proc. IEEE International Conference on Systems, Man and Cybernetics 2005, Vol.
1, 10-12 Oct. 2005 pp.542-547.
[5] Xie Yun; Yang Yiming; Deng Zeming; Liu Bingru; Yi Bo;
Design and realization of communication mechanism of autonomous robot soccer based on multi-agent system, Proc. IEEE
International Conference on Systems, Man and Cybernetics
2003, Vol 1, 5-8 Oct. 2003 pp.66-71.
[6] Erdur, R. C. ve Seylan, I., “A Framework of Cooperative Agents
with Implicit Support for Ontologies”, Lecture Notes in Artificial
Intelligence, Springer-Verlag, LNAI 4149, 416-430 (2006).
(LNAI 4149 cildi, “Cooperative Information Agents X - CIA
2006, Edinburgh, UK” bildiri kitabi olarak basilmistir.)
[7] Rahnama, Behnam and Elçi, Atilla; Upon human-robot inter
communication, RO-MAN 06 Robot Companion Design Contest, Proc. the 15th IEEE International Symposium on Robot and
Human Interactive Communication, 6-8 September 2006, University of Hertfordshire, Hatfield, UK.
[8] Elçi, Atilla, Rahnama, Behnam, and Amintabar, Amirhasan;
Security through Traffic Network: Tracking of Missing Vehicles
and Routing in TMIS using Semantic Web Services, The Second
IEEE International Conference on Technologies for Homeland
Security and Safety (TEHOSS 2006) 09-13 October 2006, Istanbul, Turkey.
[9] Elçi, Atilla and Rahnama, Behnam; Applying Semantic Web in
Engineering a Modular Architecture for Design and Implementation of a Cooperative Labyrinth Discovery Robot, 4th FAE International Symposium on Computer Science and Engineering,
European University of Lefke, 30 Nov - 1 Dec 2006,
Gemikonağı, Northern Cyprus.