Applying Mathematical Models in Software Design
Alina Andreica, Daniel Stuparu, Călin Miu
IT Department
Babes-Bolyai University
Cluj-Napoca, Romania
{alina.andreica, daniel.stuparu, calin.miu}@ubbcluj.ro
Abstract— The paper focuses on techniques for systematically
applying mathematical models in software design. We implement
a generic sorting algorithm at database level, revealing the
advantages of the approach. Based on techniques for processing
hierarchical structures at database level, a dedicated analysis
addresses means of implementing simplification and equivalence
algorithms on data structures based on modular entities. We
reveal the advantages of systematically implementing
mathematical algorithms in software design and implementation,
including the level of database processing. The novelty of the
implementation consists in applying generic algorithms at
database level and in modelling discipline and module
equivalence with equivalence and simplification algorithms.
Keywords- software design, generic sorting, hierarchical
structures, database processing, run-time efficiency, equivalence
algorithms, simplification
I. INTRODUCTION
Aiming at constructing a consistent framework for
developing integrated and distributed software systems,
software development techniques should apply object &
component oriented design [11] and use flexible n-tier
architectures [9] and efficient database management techniques
[14] for database processing.
Symbolic implementations of category theory mainly
pursue two directions: a constructive approach [8] and a
systematic logical approach [7], which enables the definition of
categories, domains, operators and their properties mainly for
automatic proving.
Applying generic techniques in software design in useful
both for design reasons and for dealing with specific problems,
which are more efficiently solved by applying mathematical
models. In this respect, the paper aims at presenting systematic
implementations of mathematical models in software design
techniques for processing hierarchical structures and
implementing equivalence algorithms at database level.
Within section 2 we present techniques for implementing
generic algorithms for sorting at database level, while section 3
is dedicated to discussing techniques for representing
hierarchic structures, data selection & processing techniques.
Section 4 addresses means of implementing simplification and
equivalence algorithms on data structures based on modular
entities. Conclusions reveal the most important topics
presented in the paper and future research directions
978-1-4673-2952-1/12/$31.00 ©2012 IEEE
II. IMPLEMENTING GENERIC SORTING AT DATABASE
LEVEL
In [3], we present a general framework, based on category theory
principles, for designing algorithms by based on generic definitions of
a Set category and Ordered set category. Algorithmic definitions
within this framework are also given in [2], while in [1] we address
the database level structure from an automated proving point of view.
Within this paper, we use this general framework by adapting it for
implementing generic sorting at database level.
Sorting & merging algorithms in various forms, including
categorical approaches are extensively studied. In [7] they appear as a
case study for algorithm synthesis and automatic proving.
The Set and OrderedSet categories are defined in a modular style
[3], being parameterized with the domain of elements. We also define
their specific operators, which can be redefined, if necessary, in
descendant domains . Inheritance is modelled by explicit call of the
inherited context / category in the current one. The OrderedSet
category [3] may be then used for defining sorting algorithms over
various domains [5]
Contextual_module SetCat(S:Symbol; D:Symbol)
//defines the semigroup S over domain D
//(with elements in domain D)
SD:=SD U {S} //set of symbols for the
defined set category
 expr sD, Canonic(s:SymbolList):=disjoint list
of symbols in lexicographical ordering;
// canonical representation in S
a,bS, S("=",a,b):= Module{
n1,n2,i : Integer; eq : Boolean; eq:=True;
//verifies set equality
n1=Length(a); n2=Length(b);
If (n1<>n2) Return False;
Else if (n1==1) Return Dom(" = ",a,b);
Else For (i=1; i<=n; if (Dom("<>",a[i],b[i]])
eq:=False; Return eq; }
 a,beS, S("<>",a,b):= not S("=",a,b);
 a,beS, S("»",a,b):= Union (a,b);
 a,beS, S("*",a,b):= Intersection(a,b);
 a,beS, S("\",a,b):= Complement(a,b);
End Contextual module
For a domain Dom with the equality operator "=", Dom("=", a, b)
tests the equality of the two expressions a, b over Dom and if an order
operator "<" is also defined on Dom, the Dom("<", a, b) is used for
verifying over Dom the corresponding relation between two
expressions . Operators "<=", ">", ">=", "<>" are used in a similar
manner over a domain Dom
A categorical form of a sorting algorithm provides a general
context for performing sorting, over various domains.
87
 The ordered set category inherits the set category by explicitly The SQL functions “GreaterThan” and “LessThan” on
calling the corresponding module. We also define the operators "<", tuples are similarly implemented, based on the definitions:
">=", ">", ">=" referring to the lexicographical ordering of set (n1,n2) > (m1, m2) œ n1>m1 and n2>m2
elements over the definition domain (see definitions below).
Contextual_module (n1,n2) < (m1, m2) œ n1<m1 and n2<m2 ,
OrderedSet(S:Symbol; Dom:Symbol, op="<") where n1,n2, m1, m2  Integers
// defines an ordered set S over domain D SetCat
(S,Dom); The SQL stored procedure for bubble-sort and counting-
 a,beS, S("Rel",a,b):=Module{ i=1; rel=0; sort algorithms on tuples represented at database level are
n1=Length[a]; n2=Length[b]; nr=Min[n1,n2]; presented in [5] . The temporary table @tbl_manevra used for
While (i<=nr && rel==0) {
If (Dom["<",a[i],b[i]]) rel=-1; retaining auxiliary indexes (IDX column) significantly
If (Dom[">",a[i],b[i]]) rel=1; increases run-times compared to bubble sort – see table 1.
i=i+1; }
If (rel==0 && n1>nr) rel=1; As known, generic layers reduce run-time efficiency [3] but
If (rel==0 && n2>nr) rel=-1; these algorithms model tuple sorting, which is not implicitly
Return rel ; } defined at database level, and therefore has to be generically
 a,beS, S("<",a,b):= S("Rel", a, b)==-1;
extended. We may conclude this section by revealing the
 a,beS, S("<=",a,b):=S("<",a,b) or S("=",a,b);
 a,beS, S(">",a,b):= S("Rel", a, b)==1;
design advantages of the generic approach for modeling
 a,beS, S(">=",a,b):=S(">", a, b) or S("=",a,b); specific contexts; in this respect, we extend the implementation
S("sort", L:list) :=Module{ i,j,n:Integer; of order relations and sorting algorithms at database level.
aux:Symbol; li:List, n=Length[L]; li=L;
for (i=0;i<n;i++)
for (j=i + 1;j<=n;j++) III. HIERARCHICAL STRUCTURES - REPRESENTATION AND
if (Dom (op, li[j], li[i]) PROCESSING PRINCIPLES
{aux=L[i]; li[i]=li[j]; li[j]=aux} Return li;}
S("sort-n", L:list) :=Module{i,j,n:Integer; Hierarchical data structures are often necessary to be
LS:SymbolList; Poz:IntegerList; n=Length[L]; processed in a database; such structures may be retained in
//sorting by counting relational databases by means of ascendant / successor pointers
for (i=0;i<n;i++) { Poz[i]=0;
for (j=0;j<n;j++) if (j<>i) in dedicated tables. Principles for processing hierarchical
if (Dom (op,L[j],L[i]]) Poz[i]++; structures and a comparison of their processing techniques are
LS[i]=L[Poz[i]]; } presented in [4]
return LS; }
End Contextual module These tehchiques are applied within AcademicInfo system
for educational management, that we have designed and
The OrderedSet categorical definition of the sorting algorithm can
be applied, in a parametric manner, for each domain .We applied this implemented [4]. We represented curricula as hierarchical
generic framework in implementing a sorting algorithms for tuples structures [5] based on a modular structure. A curriculum
(pairs), at a database level, on the table Tbl_Optiuni, which retains comprises a set of study modules, where a study module
admission options for our AcademicInfo system (see 3) consists of either a set of disciplines, or a set of other modules.
For each module we retain, in a dedicated table, the identifiers
Tbl_Optiuni [IdSpec, IdOption] of its ascendant module, first descendant module, preceding
The tuple type which models this structure is defined by the module (same tree level) and successor module (same level):
SQL sequence: Tbl_Modules [module_id, ascmodule, descmodule,
USE [EvidscolAdmitere] GO precmodule, succmodule, modulename, …, level,
IF EXISTS (SELECT * FROM sys.types st JOIN
moduletype_id, credit_tot, duration, isLeaf ]
sys.schemas ss ON st.schema_id = ss.schema_id WHERE
st.name = N'TupleTableType' AND ss.name = N'dbo') moduletype_id is mainly used in order to activate or
DROP TYPE TupleTableType GO deactivate the visibility of the module in various reports that
/* Creates the TupleType for retaining (idspec, are generated based on curriculum information.
idoption) */
CREATE TYPE TupleTableType AS TABLE The data selection techniques we have implemented
( [IDSpec] INT NOT NULL evolved from complex and multi-level sub-select views that
, [IDOption] INT NOT NULL) GO
SELECT * FROM sys.table_types contained all descendant modules for each module. Views are
instantly updated by the database engine, being therefore
The equality of tuples is verified by the SQL function: convenient when all selected data is needed. Yet, this technique
USE [EvidscolAdmitere] GO
IF EXISTS (SELECT * FROM sys.objects WHERE is dependant of a maximum number of levels in the
object_id = OBJECT_ID(N'[dbo].[EqualWith]') AND type hierarchical structure that corresponds to the number of JOIN
in (N'FN', N'IF', N'TF', N'FS', N'FT')) operations. We solved this problem by building stored
DROP FUNCTION [dbo].[EqualWith] GO procedures parameterized with the level value, data selection
CREATE FUNCTION [dbo].[EqualWith](
@IDSpec1 AS INT, @IDOption1 AS INT, operation being performed dynamically, in respect with this
@IDSpec2 AS INT, @IDOption2 AS INT ) value. Nevertheless, the database engine has to rebuild
RETURNS BIT AS BEGIN execution plans at each run time both when using views and
DECLARE @ResultVar AS BIT stored procedures, operation which has a certain complexity.
IF (@IDSpec1 = @IDSpec2) AND (@IDOption1 =
@IDOption2) Stored procedures enable efficient data selection based on
SET @ResultVar = 0; -- TRUE
ELSE SET @ResultVar = 1; -- FALSE the module data. Procedures are parameterized as strongly as
RETURN @ResultVar END GO possible for minimizing the volume of selected data.

88
 Postorder type n-ary tree evaluation algorithms based on
the above described tree representation are used in order to
compute the total number of credits for curricula of weighted
average grade of students on various modules. Some efficiency
studies we have performed on processing the hierarchical
structure are also given in [15].
The view technique is convenient (fast at the database
engine level) for extracting complex data. Still, when
transmitted to client modules, large views may induce
inefficiency by transferring a large amount of data via the
network. By replacing such program sequences with strongly
parameterized stored procedures, we succeeded to improve
run-time efficiency with up to 80%. A systematic comparison
of hierarchic structures processing techniques is given in [4].
IV. IMPLEMENTING EQUIVALENCE ALGORITHMS ON
MODULE HIERARCHIC STRUCTURES
Within this section we present means of implementing
equivalence algorithms [6] on the above described modular
structures [5]
Didactic entities, named activities (or in particular
disciplines) are retained in a dedicated table – Tbl_activitati :
IsActivity(d) := ­®true, d  Tbl _ Activitati [idactivitate]
¯ false, otherwise
Disciplines are organized in hierarchies of modules, where
modules are retained in a dedicated table – see previous
section. In our hierarchic representation, all non-leaf modules
consist only of modules.
IsModule(m) := ­®true, m  Tbl _ Modules[idmodul ]
¯ false, otherwise
IsLeafModule(m) := ­®true, d  m : IsActivity [d]
¯ false, otherwise
Let d1, d2 be two didactic activities (in particular,
disciplines). We use the notation ‘~’ for describing the
equivalence of two activities / disciplines d1, d2 in the sense
that they are curricular-equivalent: d1 ~ d2 .
‘~’ is an equivalence relation [6] since it verifies
reflexivity, symmetry, transitivity properties.
The canonical representative of a disciplines’ equivalence
class will be the ‘newest’ defined discipline i. e. having the
biggest identifier code.
We implemented, by means of stored a procedure, the
simplification algorithm for determining the canonical
representative [6] for a given discipline. Based on this
algorithm, we may also test the equivalence of two disciplines
by verifying they have the same canonical representative [5]:
CREATE FUNCTION [dbo].[FCT_GetCanon]
(@IDA AS INT ) RETURNS INT AS BEGIN
DECLARE @rez AS INT;
WITH Explorer AS (
SELECT idactivitate, idactivitateechiv
FROM echivalari_discipline
WHERE idactivitate = @IDA UNION ALL
SELECT M.idactivitate, M.idactivitateechiv
FROM echivalari_discipline M INNER JOIN Explorer E
ON M.idactivitate = E.idactivitateechiv )
89
SELECT @rez = MAX (idactivitate) FROM Explorer
RETURN @rez END
FCT_SuntDisciplineEchivalente MS SQL function [5]
verifies if two activities are equivalent by testing if they have
the same canonical representative:
CREATE FUNCTION
[dbo].[FCT_SuntDisciplineEchivalente] ( @d1 as INT,
@d2 as INT) RETURNS BIT AS BEGIN
DECLARE @c1 AS INT DECLARE @c2 AS INT
DECLARE @r AS BIT
SELECT @c1 = [dbo].[FCT_GetCanon] (@d1)
SELECT @c2 = [dbo].[FCT_GetCanon] (@d2)
IF (@c1 = @c2 ) OR (@d1 = @d2) BEGIN
SET @r = 1 END
ELSE BEGIN SET @r = 0 END
RETURN @r END
We further implement equivalence verification for modules
[5]. Let m1, m2 be two modules that contain distinct activity
representatives. We define the equivalence relations between
modules as “mapping” (from one module to the other) only
disciplines that are equivalent. Since in our hierarchic
representation, all non-leaf modules consist only of modules,
we introduce the following definition for module equivalence:
­(d1  m1 , ! d 2  m2 : d1 ~ d 2 ) š
°(d  m , ! d  m : d ~ d ), IsLeafModule(m )
m1 | m2 œ °° 2 2 1 1 1 2 1
®
° (md1  m1 , ! md2  m2 : md1 | md2 ) š
°
°¯ (md2  m2 , ! md1  m1 : md1 | md2 ), otherwise
Two leaf modules are equivalent iif all contained
disciplines are equivalent; two non-leaf modules are equivalent
iif all contained modules are equivalent. By generically
denoting with ‘~’ an equivalence relations for activities or
modules as above defined, we may state that:
m1 | m2 œ (d1  m1, ! d2  m2 : d1 ~ d2 ) š
(d2  m2, ! d1  m1 : d1 ~ d2 )
For a leaf module m, we consider Canonic (m) =
{Canonic(d) | dm} – the set of canonical representative for
the contained activities / disciplines . It can be shown that two
leaf equivalent modules have the same sets of canonical
module representatives. For a module m we can recursively
compute its canonical representative set as [5]:
Canonic(m) = ­ {Canonic(d ) | d  m}, IsLeafModule[m]
®
¯ {Canonic(md) | md  m}, otherwise
Intuitively, the canonical set of a module is obtained by
“flattening” its module sub-tree and computing the union set of
all canonical sets corresponding to its descendant leaf modules.
Generically, we may state: Canonic (m) = {Canonic(d) | dm}
We further implement these hierarchic processings at a
database level, by means of stored procedures. We give below
the MS SQL function that computes the canonical set of a
module (canonical set of all disciplines belonging to its
descendant leaf modules).
CREATE FUNCTION [dbo].[FCT_GetActivitatiEchivModul]
(@idModul AS INT)
RETURNS @rez TABLE (idactivitate INT) AS BEGIN
-- select leaf modules from the module parent ..
WITH Explorer AS(
SELECT idmodul, legaturaasc, denumiremodul,
nivel, semstudiu
 FROM modul WHERE idmodul = @idModul UNION ALL
SELECT M.idmodul, M.legaturaasc,
M.denumiremodul, M.nivel, M.semstudiu
FROM modul M INNER JOIN Explorer E ON
M.legaturaasc = E.idmodul )
-- select disciplines from leaf modules
INSERT INTO @rez
SELECT ad.idactivitate FROM Explorer mc
INNER JOIN modul_discipline md on
mc.idmodul=md.idmodul
INNER JOIN activitati_discipline ad ON
md.idactivitate = ad.idactivitate
RETURN END
USP_SuntModuleEchivalente-CuCanonic – see [5] verifies
module equivalence by testing the equality of the canonical
sets. An alternate approach – MS SQL procedure
USP_SuntModule_Echiv, which implements the module
equivalence definition is also desribed in [5] .
A run time benchmark for 20 / 100 activities per module –
see table 2 – is computed in order to compare stored
procedures for module equivalence by implementing the
definition versus verifying canonical sets; we may obviously
notice that the canonical approach is more efficient
V. CONCLUSIONS AND FUTURE WORK
The categorical and parameterized approach reveals a
general method for defining computational domains: this
approach is used for implementing generic sorting procedures
at database level. We reveal the advantages of the approach in
order to deal with specific problems. The novelty of the
implementation consists in applying generic algorithms at
database level and in modelling discipline and module
equivalence with equivalence and simplification algorithms.
We also deal with techniques for representing and
processing hierarchical data structures that are used to
implement simplification algorithms at database level and
addresses efficiency issues in this respect. The method we
propose addresses means of implementing simplification and
equivalence algorithms on data structures based on modular
entities. We reveal the advantages of applying the algebraic
equivalence model at a database level and of applying
canonical representatives’ properties. Case studies are
performed on our AcademicInfo information system that we
have designed and implemented
Future work is related to refining techniques of software
design by implementing specific mathematical models and
TABLE I. RUN TIME BENCHMARK FOR GENERIC SORTING ALGORITHMS
Generic algorithm BubbleSort
100 tuples 0.851 sec
1000 tuples 65.305 sec
10000 tuples Exponential – 1624.521 sec
TABLE II. RUN TIME BENCHMARK FOR EQUIVALENCE PROCEDURES
Run time (ms) for 10.000
Procedure modules, 20 disciplines /
compared module
USP_SuntModule_Echiv 28895
USP_SuntModuleEchivalente-CuCanonic 1394
90
properties in order to increase software proficiency. We also
intend to study additional means of processing hierarchical
structures and complexity analysis directions with the view to
improving software design techniques.
Acknowledgment We thank the development team in our
IT department for contributing to AcademicInfo’s
implementation: Florina Covaci, Gabriel Pop, Monica Bojan,
Carmen Pavel, Kerekes Hunor, Zölde Attila, Kerekes Tünde,
Andrei Popescu (and authors).
REFERENCES
[1] Alina Andreica, D. Stuparu, I..Mantu, “Symbolic Modelling of Database
Representations”, International Symposium on Symbolic and Numeric
Algorithms for Scientific Computing 2005, IEEE Press, 2005, p 59-62
[2] Alina Andreica, Calcul simbolic şi aplicaţii, Dacia, Cluj-Napoca, 2005
[3] Alina Andreica,”Implementing Parameterized Type Algorithm
Definitions in Mathematica”, IEEE Proceedings, Eighth International
SYNASC Symposium, 2006, P.35 - 40
[4] Alina Andreica, D Stuparu, C Miu, “Design Techniques in Processing
Hierarchical Structures at Database Level”, Iadis Information Systems
2010 Proc, Porto, Ed: M. Nunes, P. Isaias, P. Powell, 2010, P. 483-488
[5] Alina Andreica, D Stuparu, C Miu, Mathematical Models in Software
Design - Generic Sorting and Equivalence Algorithms, Theory and
Practice in Modern Computing 2012, 17-19 July 2012, Lisbon, Portugal
[6] Bruno Buchberger, R. Loos, Algebraic Simplification, Computing,
Suppl. 4, Springer Verlag, p.11-43, 1982
[7] B. Buchberger, "Automatic Invention and Verification by Lazy
Thinking", D. Petcu, V. Negru, D. Zaharie, T. Jebelean Eds, Proceedings
of SYNASC 2003, p. 2-26
[8] L. Dragan, S. Watt, "Performance Analysis of Generics in Scientific
Computing", SYNASC 2005 International Symposium, JD Cantarella
editor, IEEE Computer Society Press, 2005, p. 93-100
[9] Client/Server and the N-Tier Model of Distributed Computing,
Micromax Information Services Ltd. 1999
[10] Dhawan P., .NET Remoting Performance, Building Distributed
Applications with MS .NET, MS Press, 2002
[11] Gamma E, Helm R, Johnson R, Vlissides J, Design Patterns, Teora, 2002
[12] Larson B., Delivering Business Intelligence with Microsoft SQL Server
2005, McGraw-Hill/Osborne, 2006
[13] MCAD/MCSD Training Kit: Developing XML Web Services & Server
Components with MS Visual Basic .NET and MS Visual C# .NET
Editor, MS Press, Redmond, 2003
[14] Ramakrishnan, R., Database Management Systems, 3rd edition, New
York: McGraw-Hill, 2002
[15] D. Stuparu, Alina Andreica, I.Mantu, “Comparing Access Techniques
on Databases in Distributed Application Frameworks”, Collaborative
Support Systems in Business and Education, Cluj-Napoca, 2005, p 1-10
CountingSort
1.042 sec
272.456 sec
Exponential – 8743.947 sec
Run time (ms) for 10.000
module, ~100 disciplines /
compared module
136941
1717