DISTRIBUTED PLANNING THROUGH GRAPH MERGING

Damien Pellier

Universit

e Paris Descartes University, Laboratoire d’Informatique Paris Descartes, 45, rue des Saint P

ere, Paris, France

Keywords:

Distributed problem solving, Cooperation, Coordination, Multi-agent planning, Planning graphs technics.

Abstract:

In this paper, we introduce a generic and fresh model for distributed planning called “Distributed Planning

Through Graph Merging” (DPGM). This model uniﬁes the different steps of the distributed planning process

into a single step. Our approach is based on a planning graph structure for the agent reasoning and a CSP

mechanism for the individual plan extraction and the coordination. We assume that no agent can reach the

global goal alone. Therefore the agents must cooperate, i.e., take in into account potential positive interactions

between their activities to reach their common shared goal. The originality of our model consists in considering

as soon as possible, i.e., in the individual planning process, the positive and the negative interactions between

agents activities in order to reduce the search cost of a global coordinated solution plan.

1 INTRODUCTION

The problem of plan synthesis achieved by a group

of autonomous agents in order to reach a common

goal is one of the central problem of distributed arti-

ﬁcial intelligence. Increasingly new application areas

can beneﬁt from this research domain: e.g., robotics

(Sariel et al., 2008), web services (Pistore et al., 2005)

when considering actions as services and plans as

composition schemes, decision making (Wilkins and

desJardins, 2001), where planning process is viewed

as an expert able to guide the search of a plan or a pro-

cedure. In all these applications, the implementation

of a centralized approach of planning is often impos-

sible due to technical constraints, e.g., in robotics, no

robot has enough computational resources to plan for

the whole robots team, or organizational constraints,

e.g., two concurrent web services cannot share impor-

tant business data.

Classically, multiagent planning (Durfee, 2000) is

deﬁned as a planning process involving a group of

agents, i.e., a process that takes as input the actions

models of the agents, a description of the state of

the world known by the agents, and some objectives

and returns an organized collection of actions whose

global effect, if they are carried out and if they are

performed as modeled, achieves the objectives. Such

a deﬁnition is correct, but hides the complexity of the

different steps of a distributed planning process. Ac-

tually, a multiagent planning process can be divided

into ﬁve separate steps: (i) a task decomposition step

where the agents attempt to reﬁne the initial task such

that there is a matching with the set of the agents capa-

bilities, (ii) a subtask delegation step where the agents

attempt to assign sub-tasks to each other such that the

capabilities offered are sufﬁcient for the capabilities

required, (iii) an individual planning step where each

agent tries to ﬁnd a plan to solve the task allocated

in step 2, (iv) an individual plans coordination step

where the agents coordinate their activities in order to

conserve the functional integrity of the system, i.e.,

ensure that the goal of each agent stay reachable in

the global context, and ﬁnally (v) a joint plan execu-

tion step where the joint plan build by the agents is

executed in a coordinated way. Although this decom-

position is convenient to explain the problem of mul-

tiagent planning, experiences show that the ﬁve steps

introduced are interlaced: (i) step 1 and 2 are often

merged due to the existing link between the agents

capabilities and the task decomposition, (ii) the joint

plan execution involves replanning due to a failure

and force into backtrack to step 1, 2 and 3, and (iii)

the coordination can be executed either before, after

or during the planning. This remark brings to light

the lack of work to merge and articulate the different

steps of multiagent planning.

In order to answer in part to this challenge, we

introduce a multiagent planning model, called “Dis-

tributed Planning through Graphs Merging” (DPGM),

that covers the four ﬁrst steps of the multiagent plan-

ning process previously described. Our model fo-

cuses on generic and completely distributed mecha-

128

Pellier D. (2010).

DISTRIBUTED PLANNING THROUGH GRAPH MERGING.

In Proceedings of the 2nd International Conference on Agents and Artiﬁcial Intelligence - Agents, pages 128-134

DOI: 10.5220/0002702601280134

 SciTePress

nisms in order to allow a group of agents to jointly

elaborate a global shared plan and perform a collec-

tive goal. We assume that no agent can reach the goal

alone. By elaboration, we mean plan production and

not instantiation of predeﬁned global plan skeletons

(D’Inverno et al., 2004) or distributed coordination of

individual plans based on planning techniques (Iwen

and Mali, 2002; Tonino et al., 2002; Cox and Dur-

fee, 2005). This is achieved by composing agents ca-

pabilities, i.e., the actions they can execute, for the

beneﬁt of the group. At the team’s level, agents ex-

change constraints about their own activities based

on the structure of planning graph (Blum and Furst,

1997). At the agent’s level, each agent merges the

constraints received from the others into its own plan-

ning graph and takes advantage of these constraints in

order to extract an individual plan conﬂict free based

on a CSP technique (Kambhampati, 2000).

The rest of this paper is organized as following:

section 2 proposes an overview of the model and its

primary deﬁnitions, and ﬁnally section 3 introduces

the dynamic of the distributed planning through graph

merging approach.

2 PRIMARY DEFINITIONS

Let us ﬁrst deﬁne the primary deﬁnitions of DPGM

based on (Blum and Furst, 1997). Operators are de-

ﬁned in STRIPS (Finke and Nilsson, 1971). We are

dealing here only with classical planning assumption,

i.e., deterministic, static, implicit time and fully ob-

servable operators. We note precond(o), the precon-

ditions of an operator o, and respectively effects

(o)

the positive effects of o and effects

−

(o) the negative

effects of o. An action is a ground instance of an op-

erator. We say that two actions a and b are dependent

if: a deletes a precondition of b: the orderings a ≺ b

will not be permitted; or a deletes a positive effect of

b: the resulting state will dependent on their order; or

symmetrically for negative effects of b with respect to

a: b deletes a preconditions on a positive effect of a.

A planning graph G is a directed, leveled graph

organized in an alternated sequence of propositions

and actions hP

, A

, P

, . . . , A

i−1

, P

i. The ﬁrst level of

the planning graph is a proposition level P

that de-

ﬁnes the initial belief state of an agent. The levels A

with i > 0 are action levels that deﬁne the set of ac-

tions applicable from the proposition levels P

and the

levels P

i+1

deﬁne the proposition produced by the ac-

tions of A

. Edges of planning graph explicitly repre-

sent relations between actions and propositions. Ac-

tions in an action level A

are connected by precondi-

tion edges to their preconditions in level P

, by add-

edges to their positive effect in level P

and by delete

edges to their negative effects in level P

. At each level

, every proposition p ∈ P

are propagated to the next

level P

i+1

by a dummy action no-op that has a single

precondition and a single positive effect p.

Two actions a and b in level A

are mutex if either

a and b are dependent or if a precondition of a is mu-

tex with a precondition of b. Two propositions p and

q in P

are mutex if every action in A

i−1

that has p

as a positive effect (including no-op actions) is mutex

with every action that produces q. The set of mutual

exclusion relations at a proposition level P

and action

level A

respectively µP

and µA

A ﬁxed-point level in a planning graph G is a level

i such that for ∀ j > i, level j of G is identical to level

i, i.e., P

= P

, µP

= µP

, A

i−1

= A

j−1

and µA

i−1

µA

j−1

An agent α is a couple α = (O, s

) where O is the

set of operators that describes the capabilities of α,

and s

is its initial agent state.

Furthermore, we introduce precond(α) that de-

ﬁnes the set of atoms used in the precondition of the

agent operators of α, effects

(α) and effects

−

(α) that

represent respectively the set of atoms used in the pos-

itive and negative operators effects of α. We assume

that these sets of atoms constitute the public part of

an agent, i.e., agents can access anytime to this infor-

mation from the others during the planning process.

An action a

contained in the planning graph of

an agent α at level i threats the activity of an agent

β iff a proposition p ∈ effects

−

) is uniﬁable with a

precondition or a positive effect of an operator o ∈ O

An action a

contained in the planning graph of

an agent α at level i promotes the activity of β iff

p ∈ effects

) is uniﬁable with a precondition or a

positive effect of o ∈ O

The threat deﬁnition expresses the classical nega-

tive interactions between agents. If an agent executes

an action that deletes a property needed by another

agent, their activities are confrontational. The pro-

motion deﬁnition formulates the positive interactions

between agents. If an agent produces a property use-

ful to another agent, i.e., that is needed to execute one

of its own actions, their activities reinforce each other.

A multiagent planning problem P is a tuple P =

(A, g) where A is the set of agents that must solve the

problem and g deﬁnes the goal, i.e., a set of proposi-

tions that has to be satisﬁed by the agents (see Fig. 1).

The individual goal g

of an agent α for

a multiagent planning problem P = (A,g)

with α ∈ A is deﬁned by: g

= {p ∈

g | p is uniﬁable with an effect q ∈ effects

(α)}.

The goal decomposition relies on the fact that an

agent can only reach predicates deﬁned in the positive

DISTRIBUTED PLANNING THROUGH GRAPH MERGING

129

Figure 1: A simple logistic example with three agents: the

agents ag1 and ag2 can load and unload containers and

the agent ag3 can move containers. The global goal to

reach is g = {at(c1, l2), at(c2, l1), at(t1, l2), at(t2, l1)}. Ini-

tial states of the agents: s

= {at(c1, l1), at(t1, l1)}, s

{at(c2, l2), at(t2, l2)}, s

= {at(t1, l1), at(t1, l2)}.

effects of its operators.

A plan π

= hA

, . . . , A

i is an individual solu-

tion plan to a planning problem P = (A, g) for an

agent α ∈ A iff each A

∈ π

is independent, and

each A

is applicable to a state s

deﬁning a sequence

, . . . , s

i such that g

⊆ s

A plan Π = hA

, . . . , A

i is a global solu-

tion for a multiagent planning P = (A , g) iff: (i) the

union of the individual goal g

with α ∈ A is equal

to g, (ii) each agent α ∈ A has an individual plan

= hA

, . . . , A

i to reach its individual goal g

, and

(iii) each actions set A

with α ∈ A is inde-

pendent.

3 DPGM ALGORITHM

The DPGM procedure performs a distributed search

close to iterative deepening, discovering a new part of

the search at each iteration (see Fig. 2). First, each

agent computes its individual goals and then enters in

a loop where it iteratively: (i) expands its planning

graph, (ii) merges threats and promotions from the

others, and ﬁnally (iii) searches backward from the

last level of its graph for an individual plan. If every

agent succeeds in extracting an individual plan for its

individual goal, then every agent tries to coordinate

its individual plans to each others. Otherwise, each

agent expands its graph one more time. The iterative

loop of graph expansion, graph merging, individual

plan search and coordination is pursued until either a

global solution plan is found or a failure termination

condition is met. Let us detail the algorithm and its

properties.

3.1 Global Goal Decomposition

First of all, each agent computes its individual goal,

i.e., the subset of the global goal that is uniﬁable with

an effect of its operators. If a part of the global goal

of the planning problem does not belong to any indi-

vidual goal of the agents, then the goal decomposi-

tion fails and the DPGM procedure ends. This failure

means that the global goal cannot be reached, since

a subset of the global goal cannot be produced by

at least one agent. Otherwise, agents go to the ex-

pansion step. Consider our example, the individual

goals of the agents ag

, ag

and ag

are as follow:

= {at(c2, l1)}, g

= {at(c1, l2)} and g

{at(t1, l2), at(t2, l1)}. Each proposition of the global

goal is assigned to at least one agent. Therefore, the

agents can pursue the expansion step of the DPGM

procedure.

3.2 Planning Graph Expansion

Let an agent α = (O, s

) such that O is a set of opera-

tors with no negated atom in their preconditions, and

a set of propositions. Let g

be the individual goal

of α and A be the union of all ground instances of the

operators in O and of all no-op actions a

for every

proposition p of A. A planning graph for α expanded

up to level i is a sequence of levels and mutex pairs:

G = hP

, µP

, A

, µA

, . . . , A

i−1

, µA

i−1

, P

, µP

i. Start-

ing initially from P

= s

and µP

0, each agent ex-

pands its planning graph G from level i to level i+1 as

the expansion procedure of Graphplan. Then, it sends

to the concerned agents the threats and the promotions

contained in its planning graph. The ﬁgure 3 at level 1

shows the planning graphs of the agents ag

, ag

and

after the ﬁrst expansion. For instance, the action

move(t1,l1,l2) of ag

at level A

threats the activity of

since it deletes the precondition at(t1,l1) needed to

apply load and unload of ag

, and promotes the activity

of ag

since it adds the effect at(t1,l2) needed to apply

load and unload of ag

3.3 Planning Graph Merging

Each agent adds to its planning graph the threats and

the promotions received from the others at the current

expansion level. For instance, the action move(t1,l1,l2)

that appears in the action level A

of the planning

graph of ag

is added as a threat at level A

of the

planning graph of ag

. Take good note that only pre-

conditions and effects of move(t1,l1,l2) that are uniﬁ-

able with the atoms of the operators of ag

are added

in its planning graph. In fact, the other propositions

have no meaning for ag

, unnecessarily grow the size

of its planning graph and hinder the extraction of an

individual plan. If an added action has an empty set of

preconditions, we add a dummy precondition to keep

link from action level to proposition level (see action

load(c2,t2,l2) at level A

Fig. 3(a) and its precondition

ICAART 2010 - 2nd International Conference on Agents and Artificial Intelligence

130

FailureExpansion

A subset of the goal

proposition cannot be assigned

to the agents

An agent fails to

extract an

individual solution

plan

An agent needs a

new expansion

An agent cannot ﬁnd any

individual solution plan

Coordination

The coordination of

the indididual

solution plans fails

Individual Plan

Extraction

An agent reaches its planning

graph ﬁxed point without

containing its individual goal

P = (A, G)

All agents have a planning graph that

may contains an individual solution plan

All agents exchanges their threats and

promotions

All agents have an individual

solution for their individual goal

Coordinated

Individual

Solution plan

Each agent expands its planning graph

Planning Graph

Merging

All agents have a

coordinated

individual solution

plan

Individual Goal

Computation

Figure 2: Organization of the DPGM procedure.

ld-pre). Then, each agent completes it graph expansion

based on the new actions introduced at the current ex-

pansion level. From now on, the planning graphs of

the agents may contain actions possibly executed by

the other agents. The agents must now check if they

are able to reached collectively the global goal and

try to search for an individual plan or if they need to

expand their planning graph one more time.

First, each agent α broadcasts the result of its

graph merging. If its individual goal g

is included in

the proposition level P

of its planning graph and g

is mutex free at level i, i.e., g

∈ P

and g

∩ µP

then α has a planning graph that may contain an in-

dividual plan of length i to reach its goal g

. If this

condition is met, the merging is a success, otherwise a

failure. Note that failure happens in two cases: (i) the

ending condition of Graphplan is met (a new expan-

sion to level i +1 will not allow α to ﬁnd an individual

plan) or (ii) its goals are not in P

or not mutex free (a

new expansion to level i + 1 may allow α to ﬁnd a

solution).

Second, each agent gathers merging results from

the other agents. If no agent fails, each agent has a

planning graph which may contain an individual plan

and tries to extract an individual plan. Now suppose

that an agent fails because its planning graph reaches

its ﬁxed-point without containing its individual goal.

The DPGM procedure fails because a subset of the

global goal is deﬁnitively unreachable. Finally, if

no previous condition holds, the agents try to expand

their planning graphs to level i + 1. In order to il-

lustrate the interlacing of expansion and merging, the

ﬁgure 3 depicts the planning graphs of the agents ag

and ag

obtained at level 3: gray boxes are threats

at t1 l1

at c1 l1

in t1 c1

at t2 l1

in t2 c1

at t1 l1

at c1 l1

in t1 c1

at t2 l1

in t2 c1

in t2 c2 in t2 c2

at c2 l1 at c2 l1

P0 A0 P1 A1 A2 P3P2

mv-premv-pre

ld-pre ld-pre

move t2 l2 l1

load c2 t2 l2

move t2 l2 l1

load c2 t2 l2

move t2 l2 l1

move t1 l1 l2

move t1 l1 l2 move t1 l1 l2

at c1 l1

at t1 l1 at t1 l1

at c1 l1

load c1 t1 l1

in t1 c1

load c1 t1 l1

unload c1 t1 l1

at t2 l1

load c1 t2 l1

load c1 t1 l1

unload c1 t1 l1

load c1 t2 l1

in t2 c2

unload c2 t2 l1 unload c2 t2 l1

move t2 l1 l2

unload c2 t2 l2 unload c2 l2 l2

mv-premv-pre

move t1 l2 l1move t1 l2 l1

ld-pre ld-pre

(a) Graph of ag

: goal reached and mutex free at level 3.

at t2 l2

at c2 l2

in t2 c2

at t1 l2

in t1 c2

at t2 l2

at c2 l2

in t2 c2

at t1 l2

in t1 c2

in t1 c1 in t1 c1

at c1 l2 at c1 l2

P0 A0 P1 A1 A2 P3P2

mv-premv-pre

ld-pre ld-pre

move t1 l1 l2

load c1 t1 l1

move t1 l1 l2

load c1 t1 l1

move t1 l1 l2

move t2 l2 l1

move t2 l2 l1 move t2 l2 l1

at c2 l2

at t2 l2 at t2 l2

at c2 l2

load c2 t2 l2

in t2 c2

load c2 t2 l2

unload c2 t2 l2

at t1 l2

load c2 t1 l2

load c2 t2 l2

unload c2 t2 l2

load c2 t1 l2

in t1 c1

unload c1 t1 l2 unload c1 t1 l2

move t1 l2 l1 move t1 l2 l1

unload c1 t1 l1 unload c1 l1 l1

mv-premv-pre

move t2 l1 l2move t2 l1 l2

ld-pre ld-pre

(b) Graph of ag

: goal reached and mutex free at level 3.

at t2 l2

at t1 l1 at t1 l1

at t2 l2

move t1 l1 l2

at t1 l2

move t2 l2 l1

at t2 l1

P0 A0 P1

at t1 l1

at t2 l2

move t1 l1 l2

at t1 l2

move t2 l2 l1

at t2 l1

move t1 l2 l1

move t2 l1 l2

at t1 l1

at t2 l2

move t1 l1 l2

at t1 l2

move t2 l2 l1

at t2 l1

A2 P3

move t1 l2 l1

move t2 l1 l2

: goal reached and mutex free at level 1.

Figure 3: Planning graphs of the agents at level 3: boxes at

are propositions and boxes at A

are actions; to simplify,

mutexes are not shown; solid lines are precondition-edges

and add-edges; dashed lines are del-edges; bold boxes show

goal propositions reached and mutex free.

and promotions; to simplify only relevant actions at

action level A

are shown.

3.4 Individual Solution Plan Extraction

The search for a solution plan in a planning graph

used in DPGM is based on a constraints satisfaction

technique introduced by (Kambhampati, 2000). This

technique has two main advantages for our approach:

empirical results demonstrate that this technique im-

proves classical Graphplan’s performance on several

benchmark problems and it can be easily modiﬁed to

extract solution plans that respect coordination con-

straints as presented in the next section. The search

consists in two steps out of scope of this paper: a plan-

DISTRIBUTED PLANNING THROUGH GRAPH MERGING

131

ning graph encoding phase, where each agent encodes

its planning graph into a CSP problem (propositions

correspond to variables and actions to values), and a

solving phase based on speciﬁc techniques adapted to

Graphplan search such as explanation based learning,

dynamic variable ordering and forward checking.

Now, consider what happens when an agent suc-

ceeds or fails to extract an individual solution. As in

the merging step, the agents must check if they are al-

ways able to reach collectively the global goal. Thus,

each agent broadcasts the result of the extraction of

its individual plan. Then, based on this information,

the agents decide if the global goal is unreachable, if a

further expansion of their planning graph is needed, or

ﬁnally if they must continue and coordinate their indi-

vidual plans. Let consider the ﬁrst case: an agent fails

to extract its individual plan and no further expansion

is possible. It means that a subset of the global goal

becomes unreachable. DPGM ends and returns fail-

ure. Consider now the second case: an agent can still

expand its planning graph. Each agent returns to the

expansion step and tries to ﬁnd a solution at the next

level. Finally, if no previous case happens, DPGM as-

sures that all agents have an individual plan to reach

all the propositions of the global goal. Therefore, the

agents must try to coordinate their individual plans.

3.5 Distributed Plans Coordination

Coordination Constraints. Remember that DPGM

merging step adds new actions in the planning graphs

of the agents. These actions deﬁne threats and pro-

motions between their activities. Thus, individual

plans may contain actions that must be executed by

the other agents involved in the planning problem. In

other words, an individual plan can be viewed as a

conditional plan, i.e., a plan which could be executed

if certain conditions are met. In our case, these con-

ditions are deﬁned as constraints of the form (a, i)

where a is an action and i the level where a must

be executed. Consider our example and the planning

graphs of ag

, ag

and ag

(see Fig. 3). The agents

, ag

can respectively extract one individual plan

at level 3:

ag1

= hload(c2, t2, l2), move(t2, l2, l1), unload(c2, t2, l1)i

ag2

= hload(c1, t1, l1), move(t1, l1, l2), unload(c1, t1, l2)i

More precisely, π

ag1

is executable if π

ag2

matches the

constraint (load(c2, t2, l2), 0) and π

ag3

the constraint

(move(t2, l2, l1), 1). Symmetrically, π

ag2

is executable

if π

ag1

matched the constraint (load(c1, t1, t1), 0) and

ag3

the constraint (move(t1,l1, l2), 1). As regards ag

it may extract several individual plans, but no one

needs the help of ag

or ag

. Thus, ag

individual

plans imply no constraint for the other agents:

ag3

= h{move(t2, l2, l1), move(t1, l1, l2)}, no-op, no-opi

ag3

= hmove(t2, l2, l1), move(t1, l1, l2), no-opi

ag3

= . . .

We call this ﬁrst kind of constraints requirement con-

straints because they express that an agent needs the

execution of some other actions at a speciﬁed time

step to execute its own plan.

Is this ﬁrst kind of constraints enough to guaran-

tee the correctness of the individual plans in a dis-

tributed context ? Not quite. Because, individual

plans may contain commitment actions, e.g., ag

committing itself to execute action unload(c2,t2,l1) at

time step 3. No constraint says that the mutex actions

of unload(c2,t2,l1) must not be executed at the same

level by the other agents. Hence, we have to consider

a second kind of constraints called commitment con-

straints of the form (a, i) that express that the mutex

actions of a speciﬁed action a must not be executed at

a given level i.

Coordination Mechanisms. In order to coordinate

their individual plans, each agent broadcasts the re-

quirement and the commitment constraints of its in-

dividual plan. Then it tries to integrate the received

constraints into its own individual plan. This integra-

tion follows a least commitment principle based on

two coordination mechanisms.

First, each agent checks if the received constraints

can be directly integrated in its individual plans pre-

viously computed. This checkout is quite simple and

does not need any replanning mechanism. Indeed,

the threats, the promotions and the mutexes are al-

ready in the agents planning graphs. Thus, agents

have all the needed information to decide if the con-

straints can be satisﬁed. Consider the constraints

related to π

ag1

: the requirement constraints are

{(load(c2, t2, l2), 0), (move(t2, l2, l1), 1)} and the com-

mitment constraints are {(unload(c2, t2, l1), 2)}. Let

the individual plan of ag

ag2

= hload(c1, t1, l1), move(t1, l1, l2), unload(c1, t1, l2)i

and let us study how π

ag2

is reﬁned to integrate the

constraints set from π

ag1

. The requirement constraint

(load(c2, t2, l2), 0) of ag

can be satisﬁed because no

action of π

ag2

at level 0 is mutex with load(c2,t2,l2).

Hence, load(c2,t2,l2) is added to π

ag2

at level 0 to check

the requirement constraint of ag

. Consider now the

commitment constraint of ag

. Is unload(c2,t2,l1) mu-

tex with an action of π

ag2

at level 2 ? In our example

the answer is no. It means that π

ag2

holds the commit-

ment constraint of ag

: (unload(c2,t2,l1),2). But what

about the commitment constraint (move(t1,l1,l2), 1) of

and (move(t2,l2,l1), 1) of ag

not yet considered ?

ICAART 2010 - 2nd International Conference on Agents and Artificial Intelligence

132

No previous individual plan of ag

holds these con-

straints.

The second coordination mechanism consists in

adding coordination constraints as CSP constraints in

the CSP problem resulting from the planning graph

encoding. The key idea of this mechanism is to ex-

tract an individual plan that takes into account the in-

teractions between the activities of the agents. Re-

member that each agent encodes its planning graph in

a CSP where propositions correspond to variables and

actions to values. Thus, the question is how to encode

requirement and commitment constraints into CSP

constraints ? Let a coordination requirement con-

straint (a, i), this constraint cannot be directly added

to the CSP. Suppose that an agent must ﬁnd an indi-

vidual plan satisfying the constraint (a, i) at level i.

It means that at least one proposition or variable at

level i must be supported by the action a. This con-

straint can be encoded as (p

= a ∨, . . . , ∨ p

= a)

where p

, . . . , p

corresponds to propositions at level

i + 1. Let now consider a commitment constraint

(a, i), it says that no action mutex with a can be

executed at level i. Thus, the proposition variable

at level i + 1 cannot be supported by an action mu-

tex with a. This constraints is encoded as (p

µA

(a) ∧, . . . , ∧ p

6= µA

(a) where p

, . . . , p

corre-

sponds to propositions at level i+1 and µA

(a) the set

of mutex actions of a at level i. Of course this coor-

dination mechanism is more time consuming than the

ﬁrst one because it needs to extract a new individual

plan. In our example, this mechanism will be used

by ag

to extract a coordinated individual plan satis-

fying the constraints (move(t1, l1, l2), 1) from ag

and

(move(t2, l2, l1), 1) from ag

To conclude with our example, the ﬁnal coordi-

nated individual plans obtained after the success of

the coordination step of DPGM are as follow (actions

executed by the other agents are not shown):

ag1

= hload(c1, t1, l1),

0, unload(c2, t2, l1)i

ag2

= hload(c2, t2, l2),

0, unload(c1, t1, l2)i

ag3

= h

0, {move(t1, l1, l2), move(t2, l2, l1)},

Coordination-Extraction Loop. Consider the case

where both previous coordination mechanisms fail to

coordinate individual plans. It does not mean that

there is no solution at the speciﬁed level. Indeed,

planning graphs may contain several individual plans

at a same level. Thus, the agents must return in the ex-

traction step to attempt to extract the other individual

plans and try again to coordinate the new ones until no

more individual plan can be proposed at the speciﬁed

level (otherwise until all individual plans on a given

planning graph length are exhausted).

First, let’s deal with the termination case of this

loop. If no other individual plan can be proposed at

the considered level, the agents can either return to

the expansion and try again to ﬁnd a solution at the

next level, or fail if no further expansion is possible

(failure condition of the extraction step see previous

section for more details).

Second, assume that one or several agents can

compute new individual plans at the same level, the

agents return to the coordination step and coordinate

their new individual plans. In order to illustrate this

speciﬁc loop of extraction and coordination, consider

a generic example with three agents ag

, ag

and ag

and pick up at the point where the agents are about to

coordinate their new individual plans at the same level

for the second time, having respectively proposed

the plans π

ag1

, π

ag2

and π

ag3

at iteration 1 and π

ag1

ag2

and π

ag3

at iteration 2. Each agent broadcasts

the coordination constraints of their individual plans

and stores the received constraints (requirements and

commitments) into a table at each iteration. A possi-

ble constraints table is depicted Tab. 1. For instance,

the coordination process could succeed if the individ-

ual plan π

ag1

asserted by ag

at iteration 2 matches the

constraints C

from ag

and C

from ag

or if π

ag1

matches the constraints C

from ag

and C

from

. In other words, π

ag1

is a coordinated individual

plan if it matches a combination of the coordination

constraints broadcasts by the other agents. In the ﬁrst

case, π

ag1

, π

ag2

and π

ag3

are the solution to the plan-

ning problem and in the second case, π

ag1

, π

ag2

and

ag3

Table 1: Example of constraints table at a speciﬁed level.

Iterations ag

1 C

2 C

n C

As a general rule, the coordination phase consists

in testing all combinations of constraint sets. In the

worst case, the number of combinations is exponen-

tial to the number of individual solution plans pro-

duced at a speciﬁed level. In practice, this complex-

ity is tractable because many set of constraints can be

pruned. Indeed, a constraint set can be pruned if it

contains two constraints (a

, i) and (a

, i) such that a

and a

are mutex. Moreover, the coordination pro-

cedure can record failed constraint sets into a table

as a distributed constraints nogood table, and checks

each constraints sets with respect to the recorded con-

straints. The efﬁciency of this mechanism can be very

DISTRIBUTED PLANNING THROUGH GRAPH MERGING

133

likely needed for some classes of problems and would

require a complexity analysis of the cost of nogood

caching. Finally, note that a constraints set is added to

the table only if the second coordination mechanism

fails to integrate a constraints set.

4 SUMMARY

In this paper, we introduce a fresh model for

distributed planning called “Distributed Planning

Through Graph Merging” (DPGM). This sound and

complete model uniﬁes the different steps of the dis-

tributed planning process into a single one based on

planning graph structure used in centralized planning

for agent reasoning and CSP mechanisms for individ-

ual plan extraction and coordination. The key idea

is to incorporate as soon as possible, i.e., in the lo-

cal process of planning, the coordination step. The

underlying reason for that consists in considering as

soon as possible, i.e., in the individual planning pro-

cess, the interactions between agents activities in or-

der to reduce the search cost of a global coordinated

solution plan.

REFERENCES

Blum, A. and Furst, M. (1997). Fast planning through plan-

ning graph analysis. Artif. Intell., 90(1-2):281–300.

Cox, J. and Durfee, E. H. (2005). An efﬁcient algorithm

for multiagent plan coordination. In AAMAS, pages

828–835.

D’Inverno, M., Luck, M., Georgeff, M., Kinny, D., and

Wooldridge, M. (2004). The DMARS architecture: A

speciﬁcation of the distributed multi-agent reasoning

system. JAAMAS, 9(1-2):5–53.

Durfee, E. H. (2000). Multiagent Systems. A Modern

Approach to Distributed Artiﬁcial Intelligence, chap-

ter Distributed Problem Solving and Planning. MIT

Press.

Finke, R. and Nilsson, N. (1971). STRIPS: A new approach

to the application of theorem proving to problem solv-

ing. Artif. Intell., 3-4(2):189–208.

Iwen, M. and Mali, A. D. (2002). Distributed graphplan. In

ICTAI, pages 138–145.

Kambhampati, S. (2000). Planning graph as a (dynamic)

CSP: Exploiting EBL, DDB and other CSP search

techniques in graphplan. JAIR, 12(1):1–34.

Pistore, M., Traverso, P., and Bertoli, P. (2005). Auto-

mated composition of web services by planning in

asynchronous domains. In ICAPS, pages 2–11.

Sariel, S., Balch, T., and Erdogan, N. (2008). Naval mine

countermeasure missions. Robotics & Automation

Magazine, IEEE, 15(1):45–52.

Tonino, H., Bos, A., de Weerdt, M., and Witteveen, C.

(2002). Plan coordination by revision in collective

agent-based systems. Artif. Intell.I, 142(2):121–145.

Wilkins, D. and desJardins, M. (2001). A call for

knowledge-based planning. AI Magazine, 22:99–115.

ICAART 2010 - 2nd International Conference on Agents and Artificial Intelligence

134