AROUND THE EMPIRICAL AND INTENTIONAL REFERENCES

OF AGENT-BASED SIMULATION IN THE SOCIAL SCIENCES

Nuno David

Instituto de Ciências do Trabalho e da Empresa, ISCTE/DCTI, Lisboa, Portugal

Helder Coelho

Departamento de Informática, Faculdade de Ciências da Universidade de Lisboa (FCUL), Portugal

Keywords: Agent-based social simulation, epistemological perspectives, program verification, intentional verification.

Abstract: The difficulties in constructing and analyzing simulations of social theory and phenomena, even the most

simplified, have been underlined in the literature. The experimental reference of simulation remains

ambiguous, insofar as the logic of its method turns computer programs into something more than a tool in

the social sciences, defining them as the experimental subject itself. The goal of this paper is to construct a

methodological perspective that is able to conciliate the formal and empirical logic of program verification

in computer science, with the interpretative and multiparadigmatic logic of the social sciences. This is a

condensed and revised version of David et al. (2006). We demonstrate that the method of simulation implies

at least two distinct types of program verifications, which we call empirical and intentional verification.

Furthermore, we clarify the experimental reference of simulation by demonstrating that the process of

intentional verification is contingent upon both the behaviors of the programs and the observed social

phenomena.

1 SCIENTIFIC KNOWLEDGE

AND COMPUTER PROGRAMS

The role of simulation has acquired a renewed

importance in the social sciences. From an

interdisciplinary perspective, the discipline of

Agent-Based Social Simulation (ABSS) finds its

origin in the intersection of the social and the

computer sciences (see e.g. David et al., 2004).

Whereas from an interdisciplinary viewpoint the

discipline stresses the encounter of two distinct

scientific logics, there are undoubtedly good reasons

to maintain methodology in the research agenda.

For some, the use of formal models, resulting

from the computational nature of simulation, has

been considered not only an addition to the

established methods but the basis for the emergence

of proper social sciences. Even so, the difficulties in

constructing and analyzing simulations, even the

most simplified, have been underlined in the

literature, which raises some interesting questions

around the kind of scientific knowledge that

simulation is providing.

On the one hand, the experimental reference of

simulation remains ambiguous, insofar as the logic

of its method turns computer programs into

something more than a tool in the social sciences,

defining them as the experimental subject itself – it

is programs, and not the social phenomena they

presumably represent, that are executed and tested.

On the other hand, the formal tradition of the classic

theory of computation creates a semantic gap

between the formal interpretation of program

executions, derived from the Church-Turing thesis,

and the stakeholders’ informal interpretations,

acquired through direct observation of simulations.

These difficulties suggest the elaboration of an

alternative vision as to the role played by computer

programs in scientific knowledge. How are we to

reconcile the methodologically diverse and

multiparadigmatic social sciences with a computer

science that has been able to attain a larger

David N. and Coelho H. (2006).

AROUND THE EMPIRICAL AND INTENTIONAL REFERENCES OF AGENT-BASED SIMULATION IN THE SOCIAL SCIENCES.

In Proceedings of the Eighth International Conference on Enterprise Information Systems - AIDSS, pages 31-38

DOI: 10.5220/0002463800310038

 SciTePress

consensus in regard to the conception of scientific

truth or validity?

This paper aims to present a theory of

computation for simulating social theory and

phenomena, especially with reference to its

epistemological basis, limits and particular kind of

scientific credibility. We demonstrate that the

method of ABSS implies at least two distinct kinds

of program verifications, which we call empirical

and intentional verification.

The method of this paper is that of philosophical

analysis. This is a condensed and revised version of

David et al. (2005). We address questions that are

presently found important in the field, such as:

“what kind of credibility can the execution of a

computer program ensure for analyzing a social

phenomenon?”

By demonstrating that it is the intentional

verification of programs that is doubly contingent

with both the behaviors of the programs and the

social phenomena, we clarify the experimental

reference of simulation, and identify a new category

of knowledge we can acquire about computer

programs.

2 BACKGROUND: CAUSAL

CAPABILITY OF PROGRAMS

The role of this section is to introduce an assumption

about computer science epistemology, namely that

the semantic significance of computer programs

conveys a causal capability which affects the

performance of machines if those programs are

compiled, loaded and executed.

In computer science, the notion of scientific truth

or validity has been related to an old debate, which

confronts researchers advocating the use of formal

methods for verifying programs and those defending

the use of empirical methods. By the end of the

Eighties, the debate became especially eloquent after

James Fetzer published the article “Program

Verification: The Very Idea.” Fetzer’s (1988) aim

was to reject the idea of formal verification as a

means of verifying programs, demonstrating that

computer programming is also a branch of applied

mathematics ruled by empirical research.

Fetzer’s argument consisted of distinguishing

programs as encodings of algorithms from the

logical structures that they represent. The causal

capability of programs becomes clear once we

realize that, rather than one model, we use many

models in the implementation of a single program.

Let us think of a computer program as a textual and

static entity, which may be read, edited, printed.

Given the existence of high-level programming

languages, we can think of a program as a model of

a potential solution of a problem, where the

language functions as a model of an abstract

machine.

Thus, insofar as programs are written in

languages that model abstract machines, it remains

the case that there may or may not be a suitable

correspondence between the commands that occur

within the language and the operations that are

performed by some physical machine. In fact, high-

level programming languages are related to physical

machines by means of compilers and interpreters.

The advantage of programming by means of high-

level languages is that there is a one-many

relationship between the commands that can be

written in a high-level language, and the counterpart

operations that are performed by a machine

executing them, on the basis of their translation into

machine language. The function of interpreters and

compilers is to create a causal mechanism so that

programs written in high-level languages may be

executed by target machines whose operations are

causally affected by machine code, which usually

consists of sequences of zeros and ones.

Low-level programming languages therefore

play two roles: first, that of an abstract machine, in a

way analogous to high-level languages but where,

second, unlike high-level languages, there is a one-

to-one causal relationship between the commands

that occur within a programming language and the

operations performed by a target machine. The

programming language stands for a virtual machine

that may be understood as an abstract entity, which

may or may not be causally connected with a target

machine.

Figure 1: Programs and languages as models, according to

Fetzer (1999).

From this point of view, the implementation of a

program can be seen as the action of embedding

models in other models, where the notion of

HIGH

LEVEL

LOW

LEVEL

PROGRAMS

MACHINES

Program

Program in

Machine Language

High-Level

Abstract Machine

Low-Level

Abstract Machine

Target Machine

ICEIS 2006 - ARTIFICIAL INTELLIGENCE AND DECISION SUPPORT SYSTEMS

embedding may be envisioned as a logical or a

causal relation. Figure 1 reproduces Fetzer’s (1999)

notion. The thin arrows represent a possible relation

between a program and the abstract machine

represented by a programming language. The thick

arrow represents an actual relation between a low-

level program and a target machine. The series of

three dots stands for the possible existence of

compilers and interpreters that effect some causal

connection between programs/machines at different

levels.

Although the figure shows the set of models in

the general case of computer science, it would be

possible to identify additional levels of model

embedding for the specific case of simulation – for

instance, by realizing the existence of simulation

platforms, as well as their corresponding simulation

languages. At any rate, the causal connection

between a simulation program and a target machine

can be identified at various levels, e.g., through

simulation platforms, compilers or interpreters.

3 INTENTIONAL CAPABILITY

OF PROGRAMS

Our aim is to show that ABSS programs possess an

intentional capability that surpasses their causal

capability. Our argument is organized into four

parts. We first show that the experimental reference

of simulation involves more complicated aspects

than ordinary computer science. We then define the

meaning of intentional capability of programs. Next,

we concretize our argument with canonical

examples of simulations found in literature. Finally,

we analyze the role of the intentional capability of

programs in ABSS.

3.1 The Experimental Reference of

ABSS

A question remaining in the epistemology of ABSS

consists in characterizing what a scientific

experiment consists of. If computer science is

regarded as an empirical science, then the

experimental reference of any theory about the

computation of a program in an abstract machine

consists in executing that program in a target

machine. In the software production process, this

phase is known as program verification. Thus, for

the classical theory of computation, the role of

verification is to ascertain the validity of certain

outputs as a function of given inputs, regardless of

any interpretation given in terms of any theory or

any phenomenon not strictly computational. Another

kind of experimental evaluation, which may be

confounded with the latter, is called program

validation. The role of validation is to ascertain that

the execution of a program behaves according to the

relatively arbitrary expectations of the program end-

users.

As we have mentioned, the implementation of a

program involves a sequence of models embedded in

a target machine. Each one of these models can

suggest an alternative interpretation for verifying

and describing the behavior of the program. For

instance, the vocabularies of the low-level abstract

machine (e.g., memory registers, bit logical

operations) are neither identical to the vocabularies

of the high-level abstract machine (e.g., complex

data structures, objects, graphics) nor to the

vocabularies of the model specification (e.g., agents,

grid, movement, segregation rules). From a strict

formal point of view the consistency between the

abstract machines is incommensurable. From an

empirical point of view, the relative consistency can

be tested against the behavior of the program.

But even the empirical perspective does not seem

to be able to provide any criterion to decide upon

which embedded model should be used to describe

both the behaviour of the program and the social

phenomena (that such program presumably

represents). This dilemma suggests that the logic of

the method of ABSS highlights the presence of

intentional aspects in programming and interaction

with computers.

3.2 Definition of Intentional

Capability of Programs

The intention of someone in implementing a

program is to produce processes in a target machine,

according to a certain specification, which should be

meaningful for a group of people observing the

machine. Presumably, the role of the observer is to

idealize something that should be in accordance with

the specification intended meanings. Whether the

observer’s idealizations can actually be represented

by a theory, regarded as some form of abstraction, is

not so clear. But even in the worst case, if the aim is

to infer consequences from a specification, or

establish additional premises thereon, then the

execution of a program presumes the construction of

a new theory that should disclose something more

than the theory that was considered in the first place.

This is in line with the whole idea of computing:

the belief that the execution of a program consists in

AROUND THE EMPIRICAL AND INTENTIONAL REFERENCES OF AGENT-BASED SIMULATION IN THE

SOCIAL SCIENCES

manipulating representations, which give rise to yet

other representations. Accordingly, insofar as new

representations may be formed during or after

program executions, we will use the term

“representations a posteriori” so as to distinguish

them from the program specification.

Using these terms, the arguments presented in

the preceding sections can be reformulated. Among

the models embedded in the target machine, there

are no definite reasons to choose a specific set of

representations a posteriori in terms of one model or

another. If those representations are to be justified as

valid formal consequences of the specification, they

must be tested for empirical adequacy. Nevertheless,

this depends on a fundamental condition: according

to the classic theory of computation, both the

specification and the representations must be

formulated in a first-order language. Should this

condition be granted, we could say – in a certain

sense – that the execution of a program deduces

representations a posteriori from its specification.

That being so, one way of looking upon

specifications and representations a posteriori is to

see them as describing laws, i.e. material conditions

of necessity between events or properties about the

behavior of programs, whose test for empirical

adequacy is related to two tacit methodological

conditions: Firstly, that the intended meanings of the

specifications and representations, with reference to

the behavior of the program in the target machine,

be shared by the simulation implementer and the

observers. Secondly, presumably, in the case of

ABSS, that the intended meanings of the

specifications and representations, with reference to

the actual social phenomenon, be shared by the

simulation observers. Two remarks should be made,

nevertheless. The former condition is the only one

relevant to regard simulation as an automated

procedure of formal inference, whereas the latter is

irrelevant to that effect. Consequently, that same

condition is the only one relevant to regarding

program verification within the scope of a logic of

empirical adequacy.

The way to comply with these conditions can

vary, however. Insofar as we have suggested that

they are satisfied more or less tacitly, we should

presume that the expressability of the specification

language, as well as the expressability of the

representations a posteriori, is also evaluated tacitly.

But once we realize that almost all specifications

and representations in ABSS are formulated in a

rather informal way, there is no other alternative but

to presume that the relevance of such structures must

be established through explicit and verifiable

methods. Unless the specifications and

representations have been formulated in the formal

language of the execution model, it is not

appropriate to assume that any specification or any

representation a posteriori can be translated, without

loss of generality, to a first-order language.

Thus, for example, in Schelling’s (1978) model

of ethnic residential segregation, there should be a

considerable consensus around a first-order language

capable of expressing the specification and a

posteriori representations disseminated in the

literature, where such terms as “ethnicity”,

“segregation” or “tolerance” should convey the same

meanings to the simulation implementer and to the

community of observers. This may be achieved

following one of two procedures: (i) explicitly, by

showing that the specification and representations a

posteriori can be, without loss of generality,

expressed by a first order language, or (ii) implicitly,

according to any validated methodology able to

grant that effect.

The tendency in the literature is just the opposite,

however. In the first place, the published articles

remark that the meanings of specifications in

relation to the target machine lose extensive

generality to what is intended originally. In the

second place, the published articles do not report any

attempt to formulate representations a posteriori in a

first-order language. This is sufficient to encumber

the possibility of understanding the execution of a

program as a process of formal inference that

validates its results empirically. The acceptance of a

social simulation by a community of observers

depends on interpretative aspects that go beyond

empirical adequacy, for the semantic significance of

computer programs conveys not only a causal

capability, but also an intentional capability.

By intentional capability we understand the

following: (i) the recognition that since computation

is a symbolic phenomenon, or representational, or

semantical, it is intentional insofar as we assume that

the behaviors of computers stand for other things in

the world (Smith, 1996), (ii) the recognition that

programs implemented in computers possess a

causal capability that affects the behavior of

computers, whereby the simulation implementer has

the intention of submitting behaviors that stand for

other things in the world for a community of

observers, who may or may not accept those

intended meanings, (iii) the recognition that the

simulation implementer and the observers’ intended

meanings will remain intentional insofar as the

propositions used for interpreting the observed

behavior of programs are not verified empirically.

ICEIS 2006 - ARTIFICIAL INTELLIGENCE AND DECISION SUPPORT SYSTEMS

3.3 Examples of Intentional

Capability of Programs

We argue that ABSS involves more outstanding

intentional aspects than ordinary computer science.

We illustrate three concrete examples from the work

of Axelrod (1997) and Epstein & Axtell (1996). The

examples will be used in order to show that program

verification is supported in the published articles by

means of persuasive descriptions, which are

different in kind from the ones supporting program

verification in ordinary computer science.

First Example: Axelrod (1997)

The immediate origin of the tribute model, as well as

Axelrod’s culture dissemination model (1997), is a

concern for how nation-states form. Axelrod’s

interest was heightened by the demise of the Soviet

Union and Yugoslavia (p.121). In the tribute model

(pp.121-144), the intended meaning for each actor is

a nation-state, having as fundamental characteristics

its wealth and a list of neighbors. World geography

is regarded as a unidimensional space arranged on a

line, resulting in two constant neighbors for each

nation. The model is described as follows (p.128,

our italics):

“The basic units of the model are ten actors

arranged on a line. The actors can be thought of as

independent political units, such as nations… In

each year, three actors are chosen one after another

at random to become active…The selection of actors

to be active is based upon the notion that ambitious

leaders and potential disputes arise at random…”

The initial wealth of each actor is chosen from a

“uniform distribution between 300 and 500.” These

parameters, like all the others in the model, are

described by the author as “somewhat arbitrary and

selected for convenience” (p.128). The basic

ingredient of the model is based on the notion of

“commitment.” When wealthy nations threaten less

wealthy nations with war, the latter are compelled to

pay tribute to the former, increasing the levels of

commitment between the nations. The simulation

suggests that high levels of commitment encourage

the formation of new political actors, alliances

regarded as sets of nations that act jointly for the

benefit of common interests.

Details about the implementation of the model

are not described in the article. The notion of

commitment seems to define a meaning only to the

observers of the target machine. Somewhat tacitly,

the observers must infuse specific meanings into the

specific behaviors of the executing programs. Unlike

soft artificial intelligence, it does not seem to be a

goal of the author to show that the notion of

commitment means anything for the executing

programs themselves. The tribute model “…assumes

that actors develop more or less strong commitments

to each other based upon their prior actions. These

commitments can be thought of as the result of

psychological processes or the result of political

rules of thumb.” (p.127, our italics).

Summing up, the first goal of Axelrod is to

suggest that his model is representative of the

problem of the emergence of new political actors,

even though he assumes its simplicity very openly.

The second is to suggest that the behaviors of the

executing programs may be thought of as specific

actors and commitments, as well as the result of the

emergence of new political actors.

Hence, it is insofar as the behavior of the

executing programs should be thought of as an arena

of commitments, alluding to other things in the

world – and that it is not found necessary to presume

that the notion of commitment actually means

anything for the actors considered in the executing

programs – that it becomes unnecessary to show that

the executing programs are actually representative of

that notion. It follows from here that the propositions

formulated to interpret the behavior of the program

executions, in terms of the notion of commitment,

are not verified empirically. From this point of view,

the program code does not prove relevant for the

observer, but it is rather the intention underlying its

implementation that prevails.

Some implementation details are given more

explicitly in other models. The goal of the culture

dissemination model (pp.148-177) is to analyze the

phenomenon of social influence, and explain how

local convergence can generate global polarization,

for example, explaining the emergence of regions in

the world that share identical cultural values. Actors

are distributed among constant co-ordinates in a

grid. The culture of each actor is a set of five

numbers, which we will call a quintet of numbers.

Each position in the quintet represents a cultural

feature, which can be thought of as anything by the

simulation observers, such as the color of a belt that

is worn (p.154), a gastronomic or sexual appetite.

Each cultural feature can take the values of ten

integers, ten for each feature invariably. For

example, an agent with the culture given by the

quintet “23637” means that the first feature has

value 2 and the fourth has value 3. Again, these

values can be thought of as any cultural trait in the

scope of any cultural feature, such as blue or pink

for the colour of a belt.

AROUND THE EMPIRICAL AND INTENTIONAL REFERENCES OF AGENT-BASED SIMULATION IN THE

SOCIAL SCIENCES

The intended idea of social influence is that

actors who have similar cultures should be likely to

interact and become even more similar. In the actual

program this is specified through a mechanism

called bit-flipping, upon which the probability of

interaction between two actors is set proportional to

a measure of similarity between two quintets. Thus,

at the point where the program specifies that two

actors interact, a feature upon which its traits differ

is selected and set equal to a same trait, resulting in

two actors holding the same trait for the same

feature.

Inasmuch as simplicity is openly assumed by the

author, it becomes interesting to analyze the

simplicity of model in comparison with the scientific

literature that is used to describe it. For instance, it is

usual to view culture as a system of symbols which

depend on the many interconnections between the

many traits that make up a culture, by which people

confer significance on their own experience (p.152).

According to Axelrod, his model has an advantage

over others, insofar as its bit-flipping mechanism

takes into account that the effect of one cultural

feature depends on the presence or absence of other

cultural features. Paradoxically, he states that “the

emphasis is not on the content of a specific culture,

but rather on the way in which any culture is likely

to emerge and spread” (p.153).

It becomes clear that the influence mechanism in

the model, as well as the dissemination and

emergence of culture, does not depend on the

experience of the actors as to the particular

significance of the features and traits that make up

their cultures. The observer of the simulation must,

somehow arbitrarily, infuse the behavior of the

executing programs with additional meanings, like

the ones alluded to by Axelrod, such as “value

adoption”, “the color of a belt”, “influence” and

“culture.”

Second Example: Epstein and Axtell (1996)

The semantic gap between specifications, programs

and representations a posteriori is rather patent in

Epstein and Axtell’s sugarscape model (1996). The

work analyses a series of phenomena involving

concepts such as culture dissemination, racial

segregation, friendship, sexual reproduction,

epidemiology, and a variety of economic models.

The goal is to “grow” histories – or proto-histories

(p.8) – of artificial societies, so as to simulate the

emergence of natural civilizations, by demonstrating

formally and deductively that certain specifications

are sufficient to generate the phenomena in which

the researcher is interested.

One of the book’s aims is to grow an entire

history of an artificial civilization, where concepts

like sex, culture and conflict are explored. The

storyline is presented with the following text:

“In the beginning, a small population of agents is

randomly scattered about a landscape. Purposeful

individual behavior leads the most capable or lucky

agents to the most fertile zones of the landscape:

these migrations produce spatially segregated agent

pools. Though less fortunate agents die on the

wayside, for the survivors life is good: food is

plentiful, most live to ripe old ages (…)” (p.8, our

italics)

Our italics in the text serve the purpose of

pointing out the semantic richness of some terms in

the text, notwithstanding the descriptive richness of

the whole storyline. However, the need to implement

the model in the target machine implies decreasing

the level of expressiveness from the storyline to the

program specification, and from the specification to

the program code, resulting in very simple rules. For

example, each agent in the simulation is associated

with a set of characteristics, such as fertility, visual

acuity or gender. A typical rule in the model could

be:

Agent sex rule (p.56):

– Select a neighbouring agent at random;

– If the neighbour is fertile and of the opposite sex

and at least one of the agents has an empty

neighbouring site (for the baby), then a child is

born;

– Repeat for all neighbours.

These characteristics are specified in the program

exclusively by bits in a binary word. For example, if

the first bit in the binary word is equal to one, then

the agent is male. The observer should somehow

infuse the behaviour of the executing programs with

the intended meanings of “female,” specifically all

agents that have the bit turned off.

An aim in Epstein and Axtell’s research is to

explain how transmission of culture can eventually

produce spatially distinct tribes with different

cultures. As in Axelrod’s model, they use a bit-

flipping mechanism. A culture is a binary string of

bits that can take the values of either zero or one.

From here it follows the observation of friendship

networks (p.79): when an agent is born it has no

friends, but agents who become neighbors and are

close culturally are defined to be friends. Cultural

closeness is measured by the Hamming distance,

which is obtained by comparing the binary strings

position-by-position and totaling the number of

positions at which they are different.

ICEIS 2006 - ARTIFICIAL INTELLIGENCE AND DECISION SUPPORT SYSTEMS

In a small subscript, Epstein and Axtell write

(p.79):

“We offer this definition of ‘friendship’ as a

simple local rule that can be implemented

efficiently, not as a faithful representation of current

thinking about the basis for human friendship.”

Nevertheless, by drawing connections between

friends, Espstein and Axtell offer a set of graphical

figures illustrating friendship networks in the

simulation, and comparing them to socio-political

patterns, such as connections between individual

dissidents of repressive regimes (p.80). Again, the

authors are the ones who lead the observer to

represent the executing programs with such words as

“friendship”, “culture” or “sexual gender.” This

problem is explicitly raised by the authors, who ask

at some point in the book (p.52): Had the rules that

specify the agents’ behavior not been described,

would anyone be able to guess that the agents follow

this or that rule? And their answer is:

“We do not think we would have been able to

divine it. But that really is all that is happening.”

If the question seems appropriate for us, it does

seem that the answer is based on a subtle confusion.

Let us consider Axelrod’s culture dissemination

model, where the executing programs are illustrated

by a grid of ten-by-ten (10x10) quintets of integers,

ranging from zero to nine, in constant variation

according to the bit-flipping rule. Figure 2 illustrates

what two iterations of the simulation could be, with

a set of four-by-three (4x3) cultures.

74271 87274 34872 74271 87274 34872

38493 89393 29384 38493 89293 29384

93948 38283 28383 93948 38283 28383

35998 72533 34383 33998 72333 34383

iteration n iteration n+1

Figure 2: Agents interacting are marked with a square.

Epstein and Axtell’s misunderstanding becomes

clear here. In fact, it would be possible to find out

that the agents follow this or that rule, for the

implemented rule is very simple. By simple

observation of the simulation, we would be able to

formulate the rules that govern its behavior. It does

seem to us, however, that the rules resulting from

this empirical inquiry would not be composed by the

vocabulary of the original ones. Instead of terms

such as “culture” or “friendship,” we would find sets

of integers adorned by logical or mathematical

operations or, possibly – in the case of Epstein and

Axtell’s model – by the names that stand for the

colors of certain pixels or characters observed on the

screen.

And we could say, all in all, “that really is all

that is happening.”

By all means, the intentional significance of the

original rules surpasses the causal significance of the

new rules, insofar as the interpretation of the original

rules does not result from an empirical inquiry.

3.4 The Role of Intentional

Capability of Programs

Whereas a model is built and analyzed on the basis

of observation and experimentation, it may be

considered a representation of reality. However, in

ABSS, most representations a posteriori result from

an experimental process, even though they do not

need to represent contingent conditions of necessity

between facts about the program behaviors.

The implementer’s role, in this new context,

seems to be significantly strengthened. His role is to

foster interpretations that exceed the limited

empirical expressiveness of the model, according to

the opinion of a limited community of observers.

Those interpretations should be in accordance with

the intention that underlies the implementation, and

only in that scope should they be acquired

experimentally. Hence, apart from the empirical

facts about the behavior of programs, the role of

both the implementer and the observers is to

negotiate and ascribe contingent conditions of

intentionality to the simulation outcomes.

Summing up, there are two complementary

scientific logics at stake in ABSS, one based on the

formal and empirical logic of program verification,

in which necessity conditions about the behavior of

programs are specified and verified empirically, and

another based on the experimental logic of program

verification, in which intentionality conditions about

the behavior of programs are specified and verified

experimentally, albeit not empirically, according to a

limited community of observers.

We shall establish a parallel between the roles of

empirical and intentional verification of programs.

The role of empirical verification is to exercise the

construction of programs in order to achieve

empirical adequacy between program executions and

the causal meaning of those programs. The role of

intentional verification is to exercise the

construction of specifications and programs in order

to achieve experimental adequacy between program

executions and the intentional meaning of those

programs, in the context of some limited community

of observers.

AROUND THE EMPIRICAL AND INTENTIONAL REFERENCES OF AGENT-BASED SIMULATION IN THE

SOCIAL SCIENCES

The role of the community of observers, while

acting freely, is to negotiate the intentional

conditions meant by the implementer, as well as to

reject, accept or interpret other conditions, according

to both the behavior of the program executions and

the social phenomena. Whereas the set of

representations used in ABSS may be interpreted

empirically or intentionally against the program

executions, the conditions of intentionality are the

ones that are liable to a doubly contingent

interpretation.

For example, in Schelling’s model, whether or

not an observer is willing to describe the program

behaviors with the term “segregation” depends on

his inclination to consider aggregations of like-

colored agents in the grid. The level of aggregation

might be expressed as some qualitative or

quantitative measure. However, insofar as the term

“segregation” becomes interpreted according to the

social phenomenon, the verification of the program

execution behaviors becomes subjected to an

intentional logic. For instance, the following

proposition reveals essentially empirical contents:

“There is a critical value for parameter C [the

minimum proportion of like-colored agents], such

that if it is above this value the grid self-organizes

into segregated areas of single color counters. This is

lower than 0,5” (Edmonds, 2003, p.123).

And this leads Edmonds, with the social

phenomena in mind, to conclude something that

conveys a logic of intentional verification of

programs, now liable to a doubly contingent

interpretation:

“Even a desire for a small proportion of racially

similar neighbors might lead to self-organized

segregation” (p.123, our italics).

4 CONCLUSIONS

The experimental reference of agent-based social

simulation (ABSS) becomes clear once we realize

that the knowledge acquired from the simulations is

an outcome of doubly contingent exercise that, in

spite of not being empirical, is an outcome of an

experimental exercise.

In any case, there is a question that prevails:

what kind of credibility can each verification

category ensure? With respect to intentional

verification, the answer may become clearer once

we realize that the existence of yet another kind of

program verification results from the encounter of

the formal and empirical logic of computer science

with the multiplicity of methodologies in the social

sciences, which cannot be dissociated from the

multiparadigmatic logic of the interpretation of

human social action – intentional verification is

characterized by the acquisition of subjective

elements from the programs.

Contrary to artificial intelligence, where the lack

of expressiveness of formal models has been an

obstacle to scaling up programs, this lack of

expressiveness is instrumental to the method of

ABSS. Hence, from an epistemological perspective

our theory solves a semantic dilemma by deflating

it: It releases the social simulation researcher from

the semantic conflict between the formal perspective

of computation and the informal or negotiated

perspective of computation. However, the

responsible use of a simulation suggests that not

even the social simulation researcher should invoke

his neutrality as to his own evaluation of the

simulation results.

REFERENCES

Axelrod, R. (1997). The Complexity of Cooperation –

Agent-Based Models of Competition and

Collaboration. P.U. press.

David, Nuno; Marietto, Maria; Sichman, Jaime; Coelho,

Helder (2004). “The Structure and Logic of

Interdisciplinary Research in Agent-Based Social

Simulation”. Journal of Artificial Societies and Social

Simulation (JASSS), 7(3).

David, N.; Sichman, JS; Coelho, H. (2005). “The Logic of

the Method of Agent-Based Simulation in the Social

Sciences: Empirical and Intentional Adequacy of

Computer Programs”. Journal of Artificial Societies

and Social Simulation (JASSS), 8(2).

Edmonds, B. (2003). “Towards an Ideal Social Simulation

Language”. Multi-Agent-Based Simulation II, LNAI,

v.2581, Springer-Verlag, pp.105-124.

Epstein, J.; Axtell, R. (1996). Growing Artificial Societies:

Social Science from the Bottom Up, MIT press.

Fetzer, J. (1988). “Program Verification: The Very Idea”.

Communications of the ACM, v.31, pp.1048-1063.

Fetzer, J. (1999). “The Role of Models in Computer

Science”. The Monist, 82(1), La Salle, pp. 20-36.

Schelling, T. (1978). Micromotives and Macrobehavior,

W. W. Norton & Company.

Smith, C. (1996). “The Foundations of Computing”.

Smith’s introduction to a series of books that report his

study of computing in the books The Age of

Significance: Volumes I–VI. Available at

<http://www.ageosig.org/people/bcsmith/papers>.

ICEIS 2006 - ARTIFICIAL INTELLIGENCE AND DECISION SUPPORT SYSTEMS