Page 298 -

13 Combining Mathematical and Simulation Approaches to Understand... 297

13.3 Different Ways of Representing the Same Formal Model

A somewhat controversial issue in the social simulation literature refers to the
allegedly unique features of some modelling platforms. It is important to realise
that any formal model implemented in a computer model can be re-implemented in
many different programming languages, leading to exactly the same input–output
relation. Different implementations are just different ways of representing one same
formal model, much in the same way that one can say ‘Spain’ or ‘España’ to express
the same concept in different languages: same thing, different representation, that’s
all.
Thus, when analysing the dynamics of a computer model, it is useful to abstract
from the details of the modelling platform that has been used to implement the
computer model and focus strictly on the formal model it represents, which could be
5
re-implemented in any sophisticated enough modelling platform. To be clear, let us
emphasise that any computer model implemented in Objective-C (e.g. using Swarm)
can be re-implemented in Java (e.g. using RePast or Mason), NetLogo, SDML,
Mathematica© or Matlab©. Similarly, any computer model can be expressed as a
well-defined mathematical function (Epstein 2006; Leombruni and Richiardi 2005;
Richiardi et al. 2006).
Naturally, the implementation of a particular formal model may be more straight-
forward in some programming languages than in others. Programming languages
differ in where they position themselves in the well-known trade-offs between
ease of programming, functionality and performance; thus, different programming
languages lead to more or less natural and more or less efficient implementations
of any given formal model. Nonetheless, the important point is this: whilst we
may have different implementations of the same formal model, and whilst each
of these implementations may have different characteristics (in terms of, e.g. code
readability), ultimately they are all just different representations of the same formal
model, and they will therefore return the same output when given the same input.
In the same way that using one or another formalism to represent a particular
formal model will lead to more or less natural implementations, different formalisms
also make more or less apparent certain properties of the formal model they
implement. For example, we will see in this chapter that representing a computer

5 A sufficient condition for a programming language to be ‘sophisticated enough’ is to allow for the
implementation of the following three control structures:
• Sequence (i.e. executing one subprogram and then another subprogram),
• Selection (i.e. executing one of two subprograms according to the value of a Boolean variable,
e.g. IF[boolean DD true]-THEN[subprogram1]-ELSE[subprogram2])
• Iteration (i.e. executing a subprogram until a Boolean variable becomes false, e.g.
WHILE[boolean DD true]-DO[subprogram])
Any programming language that can combine subprograms in these three ways can implement
any computable function; this statement is known as the ‘structured program theorem’ (Böhm and
Jacopini 1966; Harel 1980; Wikipedia 2007).