Norm-Oriented Programming of Electronic Institutions∗
A. Garcı´a-Camino,
J.-A. Rodrı´guez-Aguilar, C. Sierra
IIIA-CSIC, Campus UAB, 08193 Bellaterra, Spain
{andres, jar, sierra}@iiia.csic.es
W. Vasconcelos
Dept. of Computing Science, University of Aberdeen,
Aberdeen AB24 3UE, United Kingdom
wvasconcelos@acm.org
ABSTRACT
Norms constitute a powerful coordination mechanism among het-
erogeneous agents. We propose means to specify and explicitly
manage the normative positions of agents (permissions, prohibi-
tions and obligations), with which distinct deontic notions and their
relationships can be captured. Our rule-based formalism includes
constraints for more expressiveness and precision and allows the
norm-oriented programming of electronic institutions: normative
aspects are given a precise computational interpretation. Our for-
malism has been conceived as a machine language to which other
higher-level normative languages can be mapped, allowing their
execution.
Categories and Subject Descriptors
I.2.1 [Artificial Intelligence]: Applications and Expert Systems—
Law; I.2.11 [Artificial Intelligence]: Distributed Artificial Intelli-
gence—Multi-agent systems
General Terms
Languages
Keywords
Norms, Electronic institutions, MAS Programming
1. INTRODUCTION
A major challenge in multi-agent system (MAS) research is the
design and implementation of open multi-agent systems in which
coordination must be achieved among agents defined with differ-
ent languages by several designers who may not trust each other.
Norms can be used for this purpose as a means to regulate the ob-
servable behaviour of agents as they interact in pursuit of their goals
[12, 2, 3, 8]. There is a wealth of socio-philosophical and logic-
theoretical literature on the subject of norms (e.g., [10, 11]), and,
more recently, much attention is being paid to more pragmatic and
∗
This work was partially funded by the Spanish Science and Technology Ministry as
part of the Web-i-2 project (TIC-2003-08763-C02-00). Garcia-Camino enjoys an I3P
grant from the Spanish Council for Scientific Research (CSIC).
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, to
republish, to post on servers or to redistribute to lists, requires prior specific
permission and/or a fee.
AAMAS’06 May 8–12 2006, Hakodate, Hokkaido, Japan.
Copyright 2006 ACM 1-59593-303-4/06/0005 ...$5.00.
implementational aspects of norms, that is, how norms can be given
a computational interpretation and how norms can be factored in in
the design and execution of MASs (e.g. [1, 6, 7]).
A normative position [10] is the “social burden” associated with
individual agents, that is, their obligations, permissions and pro-
hibitions. Depending on what agents do, their normative posi-
tions may change – for instance, permissions/prohibitions can be
revoked or obligations, once fulfilled, may be removed. Ideally,
norms, once captured via some suitable formalism, should be di-
rectly executed, thus realising a computational, normative environ-
ment wherein agents interact. This is what we mean by norm-
oriented programming. We try to make headway along this di-
rection by introducing an executable language to specify agents’
normative positions and manage their changes as agents interact
via speech acts [9].
In this paper we present a language that acts as a “machine lan-
guage” for norms on top of which higher-level normative languages
can be accommodated. This language can represent distinct flavours
of deontic notions and relationships. Although our language is rule-
based, we achieve greater flexibility, expressiveness and precision
than production systems by allowing constraints to be part of our
rules and states of affairs. In this way, normative positions can be
further refined. Hence, constraints are considered as first-class cit-
izens in our language.
Although in this paper we restrict to a particular class of MASs,
namely electronic institutions [4], our work sets the foundations to
specify and implement open regulated MASs via norms.
Our main goal is to produce a language that supports the spec-
ification of coordination mechanisms in multi-agent systems by
means of norms. For this purpose, we identify below the desirable
features we expect in candidate languages.
Explicit management of normative positions. As a result of agents’
observable, social interactions, their normative positions [10] change.
Hence, the first requirement of our language is to support the ex-
plicit management of agents’ normative positions.
General purpose. We require that our language captures different
deontic notions along with their relationships. In other words, the
language must be of general purpose so that it helps MAS design-
ers to encode any axiomatisation, and thus specify the widest range
of normative systems as possible.
Pragmatic. We pursue a “machine language” for norms on top of
which higher-level languages can be accommodated. Along this
direction, and from a language designer’s point of view, it is fun-
damental to identify the norm patterns (e.g., conditional obliga-
tion, time-based permissions and prohibitions, continuous obliga-
tion, and so on) in the literature to ensure that the language supports

their encoding1. In this way, we shall guarantee the expressiveness
of our language, and also address pragmatic concerns by providing
design patterns to guide and ease MAS design.
Declarative. In order to ease MAS programming, we shall also
require our language to be declarative, with an implicit execution
mechanism to reduce the number of issues designers ought to con-
centrate on. As an additional benefit, we expect its declarative na-
ture to facilitate verification of properties of the specifications.
2. A RULE LANGUAGE FOR NORMS
The building blocks of our language are first-order terms (de-
noted as τ ) and implicitly, universally quantified atomic formulae
(denoted as α) without free variables . We shall make use of num-
bers and arithmetic functions to build terms; arithmetic functions
may appear infix, following their usual conventions2. We also em-
ploy arithmetic relations (e.g., =, 6=, and so on) as predicate sym-
bols, and these will appear in their usual infix notation with their
usual meaning. Atomic formulae with arithmetic relations repre-
sent constraints on their variables and have a special status, as we
explain below. We give a definition of our constraints, a subset of
atomic formulae: a constraint γ is an atomic formula of the form
τ C τ ′, where C∈ {=, 6=, >,≥, <,≤}. We need to differenti-
ate ordinary atomic formula from constraints. We shall use α′ to
denote atomic formulae that are not constraints.
Intuitively, a state of affairs is a set of atomic formulae. As we
will show below, they can store the state of the environment3, ob-
servable agent attributes and the normative positions of agents: a
state of affairs ∆ = {α0, . . . , αn} is a a finite and possibly empty
set of implicitly, universally quantified atomic formulae.
Our rules are constructs of the form LHS RHS, where LHS
contains a representation of parts of the current state of affairs
which, if they hold, will cause the rule to be triggered. RHS depicts
the updates to the current state of affairs, yielding the next state of
affairs. The grammar in Fig. 1 defines our rules, where x is a vari-
able name and LHS∗
is a LHS without set
constructors (see be-
low). The Us repre-
sent the updates: they
add (via operator ⊕)
R ::= LHS RHS
LHS ::= LHS ∧ LHS | ¬(LHS ∧ LHS) | Lit
RHS ::= U ∧ RHS | U
Lit ::= α | ¬α | x = {α′ | LHS∗}
U ::= ⊕α | α
Figure 1: Grammar for Rules
or remove (via operator ) atomic formulae αs. Furthermore, we
make use of a special kind of term, called a set constructor, rep-
resented as {α′ | LHS∗}. This construct is useful when we need
to refer to all α′s for which LHS∗ holds,e.g., {p(A,B) | A >
20 ∧ B < 100} is the set of atomic formulae p(A,B) such that
A > 20 and B < 100.
We need to refer to the set of constraints that belongs to a state
of affairs. We call Γ = {γ0, . . . , γn} the set of all constraints in
∆. Given a state of affairs ∆, relationship constrs(∆,Γ) holds iff
Γ is the smallest set such that for every γ ∈ ∆ then γ ∈ Γ. In the
definitions below we rely on the concept of substitution, that is, the
set of values for variables in a computation, as well as the concept
of its application to a term. [5].
We now define the semantics of our rules as relationships be-
tween states of affairs: rules map an existing state of affairs to a
new state of affairs. We adopt the usual semantics of production
rules, that is, we exhaustively apply each rule by matching its LHS
against the current state of affairs and use the values of variables
1Work available in http://www.iiia.csic.es/∼andres/NOPLforEIs.pdf
2We adopt Prolog’s convention using strings starting with a capital letter to represent
variables and strings starting with a small letter to represent constants.
3We refer to the state of the environment as the set of atomic formulae that represent
aspects of the environment in a given point in time.
obtained in this match to instantiate the RHS via s∗: s∗(∆, LHS
RHS,∆′) holds iff s∗l (∆, LHS, {σ1, . . . , σn}) and sr (∆,RHS ·σi ,
∆′), 1 ≤ i ≤ n,n ∈ IN , hold. That is, two states of affairs ∆
and ∆′ are related by a rule LHS RHS iff we obtain all different
substitutions {σ1, . . . , σn} that make the left-hand side match ∆
and apply these substitutions to RHS (that is, RHS · σi ) in order to
build ∆′.
Our rules are exhaustively applied on the state of affairs thus con-
sidering all matching atomic formulae. We thus need relationship
s∗l (∆, LHS,Σ) which obtains in Σ = {σ0, . . . , σn} all possible
matches of the left-hand side of a rule: s∗l (∆, LHS,Σ) holds, iff
Σ = {σ1, . . . , σn} is the largest non-empty set such that sl(∆, LHS
, σi), 1 ≤ i ≤ n,n ∈ IN , holds. We now define the semantics
of the LHS of a rule: sl(∆, LHS, σ) holds between state ∆, the
left-hand side of a rule LHS and a substitution σ depending on the
format of LHS:
1. sl (∆, LHS∧ LHS
′, σ) holds iff sl (∆, LHS, σ
′) and sl (∆, LHS
′, σ′′) hold
and σ = σ′ ∪ σ′′.
2. sl (∆,¬ LHS, σ) holds iff sl (∆, LHS, σ) does not hold.
3. sl (∆, α
′, σ) holds iffα′·σ ∈ ∆ and constrs(∆,Γ) and satisfiable(Γ·
σ) hold.
4. sl (∆, γ, σ) holds iff constrs(∆,Γ) and satisfiable((Γ ∪ {γ}) · σ)
hold.
5. sl (∆, x = {α
′ | LHS∗}, σ) holds iff σ = {x/{α′ ·σ1, . . . , α
′ ·σn}}
for the largest n ∈ IN such that sl (∆, α
′ ∧ LHS∗, σi ), 1 ≤ i ≤ n
Cases 1-3 depict the semantics of atomic formulae and how their
individual substitutions are combined to provide the semantics for
a conjunction. Case 4 formalises the semantics of our constraints
when they appear on the left-hand side of a rule: we apply the
substitution σ to them (thus reflecting any values of variables given
by the matchings of atomic formula), then check satisfiability of
constraints.4 Case 5 specifies the semantics for set constructors: x
is the set of atomic formulae that satisfy the conditions of the set
constructor.
We now define the semantics of the RHS of a rule: Relation
sr (∆,RHS,∆′) mapping a state ∆, the right-hand side of a rule
RHS and a new state ∆′ is defined as:
1. sr (∆, (U ∧ RHS),∆
′) holds iff both sr (∆,U,∆1) and sr (∆1, RHS,
∆′) hold.
2. sr (∆,⊕α
′,∆′) holds iff ∆′ = ∆ ∪ {α′}.
3. sr (∆,⊕γ,∆
′) = true iff constrs(∆,Γ) and satisfiable(Γ∪{γ})
hold and ∆′ = ∆ ∪ {γ}.
4. sr (∆, α,∆
′) holds iff ∆′ = ∆ \ {α}
Case 1 decomposes a conjunction and builds the new state by merg-
ing the partial states of each update. Case 2 caters for the insertion
of atomic formulae α′ which do not conform to the syntax of con-
straints. Case 3 defines how a constraint is added to a state ∆:
the new constraint is checked whether it can be satisfied with con-
straints Γ and then it is added to ∆′. Case 4 caters for the removal
of atomic formulae.
We extend s∗ to handle sets of rules: s∗(∆0, {R1, . . . ,Rn},∆n)
holds iff s∗(∆i−1,Ri ,∆i), 1 ≤ i ≤ n hold.
The semantics above define an infinite sequence of states 〈∆0,
∆1, . . .〉 if s∗(∆i , {R1, . . . ,Rn},∆i+1), that is, ∆i+1 (obtained
by applying the rules to ∆i ) is used to obtain ∆i+2 and so on.
Fig. 2 illustrates how
this sequence can ac-
commodate the inter-
vention of agents send-
ing/receiving messages.
The diagram shows an
initial state ∆0 (pos-
∆0 V
∆0
α01, · · · , α
0
n
l l
ag1 · · ·agn
∗
∆1 V · · ·
Figure 2: Semantics as a Sequence of ∆’s
sibly empty) that is offered (represented by “V”) to a set of agents
{ag1, . . . , agn}. These agents exchange messages, adding a record
4Our work builds on standard technologies for constraint solving – in particular, we
have been experimenting with SICStus Prolog constraint satisfaction libraries

(via “l”) {α01, . . . , α
0
n} of these messages to ∆0. After the agents
add their utterances, then the rules are exhaustively applied (repre-
sented by “
∗
”) to ∆0 ∪ {α01, . . . , α
0
n}. The resulting state ∆1 is,
on its turn, offered to agents, and so on.
Our work extends electronic institutions (EIs) [4], providing them
with an explicit normative layer. There are two major features in
EIs – the states and illocutions (i.e., messages) uttered (i.e., sent)
by those agents taking part in the EI. Illocutions I are terms p(ag, r,
ag′, r′, τ, t) where p is an illocutionary particle (e.g., inform,ask);
ag, ag′ are agent identifiers; r , r ′ are role labels; τ is a term with
the actual content of the message and t ∈ IN is a time stamp. We
shall refer to illocutions that may have uninstantiated (free) vari-
ables as illocution schemes, denoted by I¯. Another important con-
cept in EIs we employ here is that of a scene. Scenes offer means
to break down larger protocols into smaller ones with specific pur-
poses.
We differentiate seven kinds of atomic formulae in our state of
affairs ∆, with the following intuitive meanings:
1. oav(o, a, v) – object (or agent) o has an attribute a with value v .
2. att(s,w , I) – an agent attempted to get illocution I accepted at state w of
scene s .
3. utt(s,w , I) – I was accepted as a legal utterance at w of s .
4. ctr(s,w , ts) – the execution of scene s reached state w at time ts .
5. obl(s,w , I¯) – I¯ ought to be uttered at w of s .
6. per(s,w , I¯) – I¯ is permitted to be uttered at w of s .
7. prh(s,w , I¯) – I¯ is prohibited at w of s .
We only allow fully ground attributes, illocutions and state control
formulae (cases 1-4 above) to be present5; however, in formulae 5-7
s and w may be variables and I¯ may contain variables. We shall use
formulae 4 to represent state change in a scene in relationship with
global time passing. We shall use formulae 5–7 above to represent
normative positions of agents within EIs.
Thus, we can write rules for prohibiting (or permitting) actions
by default, for permitting (or prohibiting) certain actions and for
choosing which actions will be prevented or only sanctioned. For
example, in the context of a Dutch auction, agents can be prevented
for making unsupported bids or only sanctioned:

α0 ∧ ¬ (α1 ∧ T2 > T) ∧ oav(Ag, credit,C ) ∧ C < P


⊕α2
where
8
<
:
α0 = utt(dutch,w3, inform(Au, auct,A, buyer , offer(It,P),T))
α1 = utt(dutch,w3, inform(Au, auct,A, buyer , offer(It,P),T2))
α2 = prh(dutch,w4, inform(A, buyer ,Au, auct, bid(It,P2),T3))
The rule above prevents agents from issuing bids in a Dutch auc-
tion they cannot afford (their credit is insufficient). It states that if
agent Ag’s credit is less than P (the last offer the auctioneer called
for item It , at state w3 of scene dutch), then agent Ag is prohibited
to bid.

X =

α0 α1 ∧ ¬ (α2 ∧ T2 > T1) ∧ T0 > T1

∧
| X |= 1 ∧ oav(A1, credit,C ) ∧ C < P


0
@
oav(A1, credit,C )∧
⊕oav(A1, credit,C2) ∧ ⊕α3∧
⊕(C2 = C − P ∗ 0.1) ∧ ⊕(P2 = P ∗ 1.2)
1
A
where
8
>
<
>
:
α0 = utt(dutch,w4, inform(A1, buyer ,Au, auct, bid(It,P),T0))
α1 = utt(dutch,w3, inform(Au, auct, all, buyer , offer(It,P),T1)),
α2 = utt(dutch,w3, inform(Au, auct, all, buyer , offer(It,P),T2))
α3 = obl(dutch,w5, inform(Au, auct, all, buyer , offer(It,P2),T3))
The previous rule punishes agents when issuing a winning bid
they cannot pay for. More precisely, the rule punishes an agent
A1 by decreasing his credit of 10% of the value of the good being
auctioned. The oav predicate on the LHS of the rule represents
the current credit of the offending agent. The rule also adds an
obligation for the auctioneer to restart the bidding round and the
5We allow agents to utter whatever they want (via att formulae). However, the illegal
utterances may be discarded and/or may cause sanctions, depending on the deontic
notions we want or need to implement. The utt formulae are thus confirmations of
the att formulae.
constraint that the new offer should be greater than 120% of the old
price.
These examples illustrate how our language addresses the ex-
plicit management of normative positions and the pragmatic con-
cerns raised in the desiderata.
3. CONCLUSIONS AND FUTURE WORK
In this paper we have introduced a formalism for the explicit
management of the normative position of agents in electronic insti-
tutions. Ours is a rule language in which constraints can be speci-
fied and changed at run-time, conferring expressiveness and preci-
sion on our constructs. The semantics of our formalism defines a
kind of production system in which rules are exhaustively applied
to a state of affairs, leading to the next state of affairs. The nor-
mative positions are updated via rules, depending on the messages
agents send. Our formalism addresses the points of a desiderata for
normative languages introduced above.
We would like to generalise our language to cope with arbitrary
actions, rather than just speech acts among agents – this would al-
low our work to address any type of open multi-agent system. We
would also like to improve the semantics of the language in order to
support the use of temporal operators for the management of time.
4. REFERENCES
[1] A. Artikis, L. Kamara, J. Pitt, and M. Sergot. A Protocol for
Resource Sharing in Norm-Governed Ad Hoc Networks.
volume 3476 of LNCS. Springer-Verlag, 2005.
[2] R. Axelrod. The complexity of cooperation: agent-based
models of competition and collaboration. Princeton studies
in complexity. Princeton University, New Jersey, 1997.
[3] F. Dignum. Autonomous Agents with Norms. Artificial
Intelligence and Law, 7(1):69–79, 1999.
[4] M. Esteva. Electronic Institutions: from Specification to
Development. PhD thesis, Universitat Polite`cnica de
Catalunya (UPC), 2003. IIIA monography Vol. 19.
[5] M. Fitting. First-Order Logic and Automated Theorem
Proving. Springer-Verlag, New York, U.S.A., 1990.
[6] A. Garcı´a-Camino, P. Noriega, and J. A. Rodrı´guez-Aguilar.
Implementing Norms in Electronic Institutions. In Procs. 4th
AAMAS, 2005.
[7] A. Garcı´a-Camino, J. A. Rodrı´guez-Aguilar, C. Sierra, and
W. Vasconcelos. A Distributed Architecture for Norm-Aware
Agent Societies. AUCS/TR0503, Dept of Computing Sc.,
Univ. of Aberdeen, Aberdeen, UK, 2005.
[8] F. Lo´pez y Lo´pez. Social Power and Norms: Impact on agent
behaviour. PhD thesis, Univ. of Southampton, June 2003.
[9] J. Searle. Speech Acts, An Essay in the Philosophy of
Language. Cambridge University Press, 1969.
[10] M. Sergot. A Computational Theory of Normative Positions.
ACM Trans. Comput. Logic, 2(4):581–622, 2001.
[11] Y. Shoham and M. Tennenholtz. On Social Laws for
Artificial Agent Societies: Off-line Design. Artificial
Intelligence, 73(1-2):231–252, 1995.
[12] M. Wooldridge. An Introduction to Multiagent Systems. John
Wiley & Sons, Chichester, UK, Feb. 2002.