A CONFLICT-DIRECTED COORDINATION MECHANISM FOR
TRAFFIC LIGHT CONTROL IN A SIMULATED ENVIRONMENT
Jos
´
e L. Aguirre
Divisi
´
on Acad
´
emica de Inform
´
atica y Sistemas, Universidad Ju
´
arez Aut
´
onoma de Tabasco, Tabasco, M
´
exico
Jes
´
us H. Dom
´
ınguez, Ram
´
on Brena
Center for Intelligent Computing and Robotics, Tecnol
´
ogico de Monterrey, Campus Monterrey, Monterrey, M
´
exico
Keywords:
Multi-agent coordination schemes, Conflict resolution, Simulation, Traffic light control.
Abstract:
Car traffic control is a big issue nowadays, because of increasing time spent in traffic jams. A common mech-
anism that allows control of car flow is the use of traffic lights. Beyond static traffic lights’ time assignments,
we think it is possible to make traffic lights adjust the green time based on the current traffic conditions and
coordinating by themselves. This paper presents a multi-agent based coordination mechanism followed by
traffic lights in a simulated traffic intersection aiming to reduce the average car waiting time, compared to
a traditional mechanism of static green time assignation. We call the mechanism “conflict-directed” since
it is based on a conflict resolution strategy. The proposed mechanism has been tested with different cases
on one and two independent intersections in a simulated environment. An evaluation of the conflict-directed
mechanism performance is given.
1 INTRODUCTION
Car traffic control is a big issue in cities nowadays,
because of increasing time spent in traffic jams. A
common mechanism that allows control of car flow
in big cities is the use of traffic lights and of cen-
tralized mechanisms where each traffic light on an in-
tersection is assigned a constant green time. Beyond
static traffic lights’ time assignments, we think it is
possible to make traffic lights coordinate themselves
through decentralized coordination schemes, where
the green time of the traffic lights is assigned based
on the present conditions of traffic. With intelligent
green time assignments, it is reasonable to think that
the cars’ waiting time could be reduced.
Simulation can be a useful tool when exploring
coordination mechanisms applied to traffic lights be-
cause it allows us to experiment with different set-
tings and analyze the effects of them in the variables
of interest. In last years several car traffic simulators
have been proposed to show how better results can
be achieved with respect to traffic flow variables, like
cars’ route time and cars’ waiting time (van den Bosch
et al., 2003), (Balmer et al., 2004).
With this in mind, this paper presents a coordi-
nation mechanism for multi-agent (MA) systems fol-
lowed by traffic lights in a simulated traffic intersec-
tion, aiming to reduce the average car waiting time
in traffic intersections; then it is compared against
the traditional mechanism of static green time assig-
nation. We call the mechanism “conflict-directed”
(CD) since it is based on a conflict resolution strategy.
An implementation of the mechanism for conducting
some experiments has been done using a MA based
simulation environment.
The structure of the document is as follows: Sec-
tion 2 presents a description of the proposed mech-
anism. Section 3 shows the conducted experiments
along with the obtained results. Section 4 presents
some related works. Finally, in section 5, conclusions
and future work are given.
2 THE CD MECHANISM
Figure 1 shows some important concepts used in traf-
fic light control that are needed to understand the CD
mechanism (Bazzan, 2005). The death time is the
number of time steps between a change of green light
state at two consecutive traffic lights in the intersec-
483
Aguirre J., Domínguez J. and Brena R. (2009).
A CONFLICT-DIRECTED COORDINATION MECHANISM FOR TRAFFIC LIGHT CONTROL IN A SIMULATED ENVIRONMENT.
In Proceedings of the International Conference on Agents and Artificial Intelligence, pages 483-488
DOI: 10.5220/0001658104830488
Copyright
c
 SciTePress

Figure 1: A graphical rendition of some traffic light control
concepts. Time flows as indicated by the big curved arrow
at the center of the gray ring.
tion. Every traffic light in the intersection is in its red
light state during the death time. The service time is
the total number of time steps where a traffic light is
in its green light state. The cycle time is the num-
ber of time steps needed for a complete cycle around
each service time of each traffic light in the intersec-
tion, counting also the total death time; the cycle time
is represented in the figure as the grey ring. The start
time, represented by the “S” letter, is the time step
in the cycle time where a traffic light will change to
green light state. The finish time, represented by the
“F” letter, is the time step in the cycle time where a
traffic light will change to red light state.
Also, the different types of agents handled by the
mechanism must be introduced. A Car Agent repre-
sents cars; it can stop, decelerate, accelerate and turn
direction based on what it detects in its forward move-
ment direction under a “vision” limit. A Light Agent
represents traffic lights; its internal states are green
and red light colors. A LightSet Agent represents a
group of Light Agents; the LightSet is in charge of
changing the state of its aggregated Light Agents at
the same time. Each LightSet has a start time and a
finish time which determine when the LightSet will
be on its green state. A LightController Agent repre-
sents a group of LightSet Agents; it synchronizes the
LightSet Agents, determining which LightSet should
reach the green state. Finally, a Source Agent spawns
cars with a predefined probability λ into the position
where the Source agent is placed.
2.1 The Mechanism
We will call a conflict situation during distribution of
cycle time the case where some LightSet Agent is re-
questing non-available resources. In such a case, if
the requested service time were assigned, the summa-
tion of every service time of every LightSet in the in-
tersection would be greater than the cycle time. In
conflict situations, we will say that a service time
assignation has conflict or is conflictive.
The mechanism is based on the idea of transform-
ing a conflictive assignation towards the default assig-
nation, that has no conflict because the entire cycle
time is evenly distributed among the LightSets. Of
course, the idea is to solve the conflict before reach-
ing the default assignation. The mechanism, which is
shown in figure 2 as a state diagram, is followed by
each LightSet Agent on the intersection. Each Light-
Set Agent can be in any of the states of that figure.
The general logic of the mechanism is the follow-
ing: Every LightSet starts in the normal state. Each
LightSet is measuring a variable called utilization rate
that measures how crowded are its lanes. If a LightSet
measures that the utilization rate grows above some
critical utilization rate and there is not an active nego-
tiation group in the intersection, then it starts a nego-
tiation group and sends an Invitation message to other
LightSet Agents in the intersection. The LightSet will
be called the owner of the group. The message has the
purpose to request from other LightSet Agents their
required service time.
After sending the Invitation message, the owner
goes to state receivingConfirmations where he will
wait for all the Confirmation messages from other
LightSet Agents. After receiving the Invitation mes-
sage, the other LightSet Agents, which must be at
normal state because there exists an active negotia-
tion group, will register to the negotiation group with
role negotiator and they will send back a Confirma-
tion message containing their required service time.
Every negotiator goes to responding state after receiv-
ing the Invitation message. When all Confirmation
messages are received, the owner will go to deciding-
Conflict state where he will verify if there is conflict in
the assignation formed with the required service time
of each negotiator (plus the required service time of
the owner).
If there is no conflict, the owner will distribute any
not-requested service time among the LightSets, in
order to guarantee that the entire cycle time is being
used. The distribution is done following this heuristic:
“Give bigger parts of the not-requested service time
to those LightSets who require more service time”.
The owner will prepare a FinalAllocation message
ICAART 2009 - International Conference on Agents and Artificial Intelligence
484

Figure 2: State diagram for a LightSet Agent working under the conflict-directed mechanism. The initial state is normal.
that will be sent to every negotiator in the negotiation
group. The message contains the final assignation.
The message informs every negotiator to go from re-
sponding state to normal state. The owner will also
inform the LightController about the final assignation.
The LightController will change the service times ac-
cordingly and he will close the negotiation group. The
owner will return to normal state.
If there is conflict, the owner will prepare a Con-
flictAllocation message, requesting from the nego-
tiators a reduction quota. The reduction quota is
the quantity that needs to be subtracted from the re-
quested required time of the negotiator such that his
service time becomes the default service time, if the
required service time is greater or equal to the default
time (the default time is the time that results from
the default assignation). The owner will go to re-
ceivingQuotas state where he will wait for the reduc-
tion quotas of the negotiators. The negotiators will
respond with a ReductionQuota message containing
their reduction quotas. After receiving all Reduction-
Quota messages, the owner will go to solvingConflict
state where he will solve the conflict. The way the
reduction quotas are computed guaranties that more
rounds of reduction quota requests are not needed in
order to solve the conflict. The owner will solve the
conflict by taking away units from the originally re-
quested service times following the heuristic: “take
away more service time from those LightSets who
require less service time”. After solving the con-
flict, the owner will prepare a FinalAllocation mes-
sage that will be sent to every negotiator in the nego-
tiation group. The message contains the final assig-
nation. The message informs every negotiator to go
from responding state to normal state. The owner will
also inform the LightController about the final assig-
nation. The LightController will change the service
times accordingly and he will close the negotiation
group. The owner will return to normal state.
2.2 Obtaining a Solution Set
Now let us describe in detail how feasible and “good”
proposals are calculated by LightSet agents.
An allocation is a n-tuple (t
1
,t
2
, . . . ,t
n
) where
each t
i
∈ N (1 ≤ i ≤ n) is the service time allocated
to LightSet Agent i, and n is the number of LightSet
Agents in the intersection. Let A be the set of all valid
allocations, that is, the set of all allocations such that
the entire resource (i.e. the cycle time) is used, each
LightSet Agent does not have in common any portion
of the resource and each LightSet Agent has at least
the minimum service time. Let us assume that each
LightSet following the conflict-directed mechanism
has an utility function over allocations in A. Figure
3 shows the form of the proposed utility function.
The idea behind the utility function of figure 3(a)
is that the utility of a LightSet Agent does not increase
once he has obtained his required service time. A
LightSet Agent will remain indifferent if it receives
more resources than needed; the number of served
cars will not increase. Moreover, the LightSet Agent
will not accept an allocation that gives him less than
his required service time because he has already sac-
rificed the default service time.
For cases like figure 3(b), the LightSet Agent will
A CONFLICT-DIRECTED COORDINATION MECHANISM FOR TRAFFIC LIGHT CONTROL IN A SIMULATED
ENVIRONMENT
485

(a) Case: t
i
r
≤ t
d
(b) Case: t
i
r
> t
d
Figure 3: Utility function that is implicitly defined on a LightSet. t
i
r
is the required time of LightSet i and t
d
is the default time
which is common knowledge to every LightSet.
not accept an allocation that gives him less than the
default service time (the unacceptable allocation will
have an utility of 0) because the LightSet Agent can
ensure himself the default service time when he can-
not obtain his required service time. In order to sim-
plify the analysis, we assume that utility grows lin-
early between the default and required service times.
Under the assumption of the utility function just
described, we show in (S
´
anchez, 2007) that every al-
location that the conflict-directed mechanism arrives
to, maximizes the sum of the utilities that the allo-
cation gives to every LightSet. Thus, the conflict-
directed mechanism is emulating a negotiation mech-
anism that maximizes some social welfare criterion,
in this case the sum of individual utilities of each of
the agents. Let us define as U the set of allocations
in set A that maximizes the summation of the utility
of every LightSet Agent in the intersection, where the
utility function is given as depicted in figure 3.
Let us now establish what could be considered a
good solution. We start by defining a concept of dis-
tance over every allocation in set A with respect to a
perfect allocation. Figure 4 shows a resource alloca-
tion plot. The X-axis represents the required service
time, the Y-axis the allocated service time. The per-
fect allocation is represented by the straight line with
slope one: the required time is equal to the allocated
time. Each allocation corresponds to a set of n points
at the plot For example, figure 4 shows a case of an
intersection with four LightSet Agents and two differ-
ent allocations.
We define the vertical distance from any point
with coordinates (t
i
r
,t
i
) to the straight line f (t
i
r
) repre-
senting the perfect allocation as: | f (t
i
r
) −t
i
| = |t
i
r
−t
i
|
(the straight line has function: f (t
i
r
) = t
i
r
for any t
i
r
).
Thus, the vertical distance is the amount of service
time necessary for an arbitrary service time t
i
allo-
cated to LightSet i to become the required service
time of LightSet i, either from above or below because
of the absolute value involved.
We also show in (S
´
anchez, 2007) that whenever
d is minimized under the restriction that the minimal
Figure 4: Example of a resource allocation plot. Two al-
locations are plotted against the perfect allocation. Vertical
distances to the perfect allocation of each point of both al-
locations are shown.
allocation must be an element of set A, two heuristics
“pop out” when going towards the minimal distance
allocation: Give bigger parts of service time to those
LightSet agents whose required service time is bigger
and Give the same quantity of service time to Light-
Set agents with the same required service time. Un-
der the assumption that the cycle time is much bigger
than the number of LightSet Agents in the intersec-
tion, these heuristics are indeed implemented by the
conflict-directed mechanism. We call G the set of al-
locations in set A which fulfill both heuristics defined
earlier.
If the solution set of the conflict-directed mech-
anism is defined as the set of all and only those al-
locations that the mechanism arrives to, then, by the
preceding discussion, the solution set is contained in
U ∩G.
3 EXPERIMENTAL EVALUATION
For testing the mechanism, experiments were con-
ducted using a multi-agent based simulator. The sim-
ulated world is a n × m grid of cells where cars in-
habit one cell at a time. It can represent any number
of traffic intersections with various lanes in every di-
ICAART 2009 - International Conference on Agents and Artificial Intelligence
486

Table 1: Summary of experimental results for cars’ average
waiting time in one intersection without arrival rate mea-
surement.
1
◦
2
◦
N CD T-14
N,W CD T-16
N,W,E CD T-12
N,W,E,S CD,T CD,T
rection (North, East, South and West). Time is mea-
sured by simulation steps. The entire simulation is
synchronous and it is built using the synchronous en-
gine of the MadKit Multiagent platform(Madkit, ).
In the experimentation we compare the average
waiting times achieved by the CD mechanism and
the traditional mechanism. The CD mechanism was
tested in one and two intersections with and without
measurement of the arrival rate. The variables “num-
ber of sensors that count the number of incoming cars
per lane” and “time each sensor waits to measure the
arrival rate” also known as “time window” were se-
lected for making the experiments. For each variable,
we tested the mechanism with three different values
corresponding to low, medium and high categories.
Also, the CD mechanism was tested when some di-
rections in the intersection are congested. Directions
were congested incrementally: North, West, East and
South in that order. In total, 76 experiments were ex-
ecuted.
For space reasons we only present some of the
results for one intersection; similar results were ob-
tained for two intersections. Results are summarized
in tables 1 and 2. The tables show the mechanism that
achieved the lowest level of car average waiting time
on each experiment. The column on the left repre-
sents the congested directions. The columns marked
as 1
◦
and 2
◦
represent the mechanism that achieved
the first place and the second place for the same ex-
periment. Symbols CD and T represent the CD and
the Traditional mechanisms respectively. The num-
bers to the right of the symbols in the column 2
◦
in-
dicate how much that mechanism loses with respect
to the mechanism in column 1
◦
. When the mecha-
nisms obtain similar results, the names are separated
by commas in the same cell. Table 2 only shows the
results for experimentation with one “time window”
variable (7 simulation steps for arrival rate measure-
ment) and two values for the number of sensors.
3.1 Discussion of Results
We can observe that in general the CD mechanism
achieved better results than the traditional mecha-
nism. The results are even better whenever it was al-
Table 2: Summary of experimental results for cars’ average
waiting time in one intersection with seven simulation steps
for arrival rate measurement.
1 sensor 6 sensors
1
◦
2
◦
1
◦
2
◦
N CD T-6 CD T-8
N,W CD T-4 CD T-8
N,W,E CD T-5 CD T-5
N,W,E,S CD,T CD,T CD,T CD,T
lowed to see the true car arrival rate as it is the case
in table 1. For the cases where the arrival rate is mea-
sured (table 2), the measurement process produces a
constantly changing value in the car arrival rate. The
case of four congested directions is a special one, as
there is no unused service time to distribute if ev-
ery lane at every direction is congested. Under the
assumption that no direction is more important than
other, then the best thing to do is to equally distribute
the cycle time among the LightSet Agents. The re-
sults also show that the CD mechanism tends to im-
prove as the number of sensors increases, as we would
expect due to an improvement in the car arrival rate
measurement. By the contrary, the “time window”
variable did not show a clear pattern.
4 RELATED WORK
In (Gershenson, 2005) three self-organizing mecha-
nisms for traffic light control are proposed. The mech-
anisms are “aware” of changes in their environment,
and therefore are able to adapt to new situations. Be-
sides some differences in the modeling approach, they
focus on self-organization that produces automatic
coordination seen as an emergent behavior at differ-
ent intersections. In (Penner et al., 2002) it is pro-
posed a swarm-based simulation environment where
cars communicate through a pheromone model in or-
der to avoid collision. They propose a traffic light
optimization system where the strategies followed by
the traffic lights evolve in order to minimize the aver-
age waiting time of all cars in the traffic system. The
main difference with our work is that they optimize
in several intersections at once while this paper was
focused on optimization in one intersection.
In (Dresner and Stone, 2004) and (Dresner and
Stone, 2005) a multi-agent traffic management sys-
tem is described. The system implements a reser-
vation mechanism by which cars request and receive
time slots from the intersection during which the ve-
hicles may cross the intersection. The main differ-
A CONFLICT-DIRECTED COORDINATION MECHANISM FOR TRAFFIC LIGHT CONTROL IN A SIMULATED
ENVIRONMENT
487

ence with our paper is that they assume that they work
with autonomous vehicles, thus they do not necessar-
ily need to use traffic lights in an intersection. Also,
they do not use waiting time as the metric of interest,
but average delay and maximum delay. In (France and
Ghorbani, 2003) a multi-agent system is presented for
optimizing urban traffic not only in one intersection
but in several. They use a hierarchical organization
of agents, ranging from agents that control the light
patterns in one intersection to agents that coordinate
groups of intersections. The difference with this pa-
per is that they model the cars as a quantity trying
to minimize the traffic density from a global point of
view. In our work, we are centered on optimization of
independent intersections trying to minimize the car’s
average waiting time.
5 CONCLUSIONS
This paper presented a coordination mechanism for
multi-agent systems followed by traffic lights in a
simulated traffic intersection. The mechanism is
based on a conflict resolution strategy as it identifies
conflictive situations where the green time demanded
by traffic lights in an intersection is greater than the
cycle time of that intersection. The mechanism tries
to solve the conflict distributing the cycle time among
the traffic lights on the intersection. The mechanism
has been tested in a multi-agent based simulator, and
results show that it was able to reduce average car
waiting time in cases involving one, two and three
congested directions, at one and two independent in-
tersections. Under some assumptions we described,
the CD mechanism is emulating a negotiation process
that maximizes the summation of utilities.
Several improvements could be suggested to the
mechanism. Other methods, for example neural net-
works, could be proposed for improving the car ar-
rival rate measurement process. Also, more exper-
iments can be conducted increasing the number of
independent intersections, introducing diagonal lanes
for having more than four different directions, etc. Fi-
nally, coordination methods using the results provided
by the mechanism could be proposed for controlling
several intersections.
ACKNOWLEDGEMENTS
This work has been done while Jose Luis Aguirre was
full time professor at the Tecnologico de Monterrey,
and was supported by CAT145 Research Chair at the
same institution.
REFERENCES
Balmer, M., Cetin, N., Nagel, K., and Raney, B. K. (2004).
Towards truly agent-based traffic and mobility sim-
ulations. In Proceedings of the Third International
Joint Conference on Autonomous Agents and Multia-
gent Systems (AAMAS’04), pages 60 – 67, New York,
NY, USA.
Bazzan, A. L. C. (2005). A distributed approach for coordi-
nation of traffic signal agents. In Autonomous Agents
and Multi-Agent Systems, volume 10, pages 131–164.
Dresner, K. M. and Stone, P. (2004). Multiagent traffic
management: A reservation-based intersection control
mechanism. In Proceedings of the Third International
Joint Conference on Autonomous Agents and Multi-
agent Systems (AAMAS’04), pages 530 – 537, New
York, NY, USA.
Dresner, K. M. and Stone, P. (2005). Multiagent traffic
management: An improved intersection control mech-
anism. In Proceedings of the Fourth International
Joint Conference on Autonomous Agents and Multia-
gent Systems (AAMAS’05), pages 471 – 477, Utrecht,
The Netherlands.
France, J. and Ghorbani, A. A. (2003). A multiagent sys-
tem for optimizing urban traffic. In Proceedings of
the IEEE/WIC International Conference on Intelligent
Agent Technology, IAT 2003, pages 411 – 414.
Gershenson, C. (2005). Self-organizing traffic lights. Com-
plex systems, 16:29–40.
Madkit. The MadKit project. Web site.
http://www.madkit.org.
Penner, J., Hoar, R., and Jacob, C. (2002). Swarm-based
traffic simulation with evolutionary traffic light adap-
tation. In Proceedings of Applied Simulation and
Modelling (AMS 2002).
S
´
anchez, J. H. D. (2007). Two multiagent traffic light coor-
dination mechanisms for reducing average car waiting
time in a traffic intersection. Master’s thesis, Instituto
Tecnol
´
ogico y de Estudios Superiores de Monterrey -
Campus Monterrey.
van den Bosch, A. T., Menken, M. R., van Breukelen, M.,
and van Katwijk, R. T. (2003). A test bed for multi-
agent systems and road traffic management. In Pro-
ceedings of the 15th Belgian-Netherlands Conference
on Artificial Intelligence (BNAIC’03), pages 43 – 50,
Nijmegen, The Netherlands.
ICAART 2009 - International Conference on Agents and Artificial Intelligence
488