1. Coordination and conversation protocols in open multi-agent systems
Abdelkader GOUAICH, Ph.d. Student
Laboratoire Informatique Robotique et Micro-Electronique de Montpellier LIRMM Montpellier, France
ESAW 2003

2. Everywhere, Anytime Computing…
Software services available for (mobile) users everywhere and at anytime
Features of these systems:
Autonomy of components
Local control
Local interaction
Openness of the system
Multi-level heterogeneity:
Technological heterogeneity
Design heterogeneity
Developers heterogeneity
Agent oriented software engineering seems to be an interesting approach for the design, implementation and deployment of these highly distributed software system
The presented work tries to understand link between coordination protocols (norms) and conversation protocols in a multi-agent system.

3. Backgrounds: What is coordination?
Malone and Crowston [mal94] define coordination as managing dependencies among activities
Common dependencies among activities are:
Shared resource
Producer/Consumer
Prerequisite
Transfer
Usability
Simultaneity constraint
Task/Sub-Task

4. Backgrounds: What is coordination?
1) Focus is made on activity aspect of coordination:
What activity to execute?
When an activity should be executed?
Model to coordinate distributed tasks such as: Statecharts, Flowcharts, Process algebra, Lotos, SDL, Estelle …
2) Conversational Aspects of coordination
What is the structure of the conversation among the coordinating entities?
FSM, Petri-Nets, State Transition Diagrams
3) Implementation centric works
How to implement distributed software systems where software components coordinate their actions.
For instance, Linda-family coordination mediums
Implementation
Centric
Conversation
Centric
Activity
Centric
Generalisation
efforts

5. Problem statement ? Implementation Centric Conversation Activity
What is the link between the conversation protocol and the coordination protocol ?
To answer this question, the following methodology has been adopted:
Step 1: Starting from Malone and Crowson works a simple coordination model has been proposed
Step 2: Starting from this coordination model, the conversation protocol is formally induced as valid sequences of messages recognised by a defined grammar.
Implementation
Centric
Conversation
Centric
Activity
Centric
Generalisation
efforts
Agent 1
Agent 2 ?

6. Step 1: Dependency-based coordination model
Hypothesis: All the dependencies situations presented by Malone and Crowson can be expressed canonically as producer/consumer dependency:
Shared resources: p/c dependency between a resource manager and its consumers
Simultaneity: p/c dependency among a monitor and the concurrent activities
Task/SubTasks: p/c dependency between the task and its sub-tasks
So, only the producer/consumer dependency is needed to be expressed in a canonical coordination model.
The dependency-based coordinal model is formally represented by a digraph G=<A,N,T,V+,V->:
Activities: actions undertaken by processes or software components. Let A represents the set of activities.
Transferable/Notifications: represents things that are produced by the producer and consumed by the consumer. T represents the set of actual objects exchanged among activities and N represents the set of notifications objects modelling prerequisite dependencies.
V+ and V represents production and consumption arrows.

7. Step 1: Dependency-based coordination model
Role-Decomposition:
Activities of the coordination graph are decomposed into disjoint sets: Roles
A role sub-graph is the smallest graph containing all activities of the role r and the related transferable produced and consumed internally.
Roles-cut is defined as the minimal set of transferable that if all its elements were removed along with their related production and consumption vertexes this would produce a digraph with more connected components than the original one. a1 a2 a4 a6 a3 a5 a2 a1 x y a4 a6 a3 a5 e1 e2 z

8. Step 2: Defining conversation protocols from the coordination protocol
Notations:
Interaction objects set (Messages)
+ commutative law and . (dot) non commutative law
Interaction objects free monoid built using the dot law (conversations)
Marked interaction objects set
Utility set
is a utility function to remove marks from a sequence of interaction objects
projection of an interaction object sequence on a sub-set alphabet
For an activity node , a+ represents the set of production arrows; a- represents the set of consumption arrows.
Given a relation R, represents a finite composition of the relation R:

9. Step 2: Defining conversation protocols from the coordination protocol
A rewriting system among conversations is defined by the rewriting relation as follows:
are alphabet elements
are sequences of interaction objects
Example: Uo U1 U2 U3 U4 U5 R Uo U1 U2 U3 U4 U5

10. Step 2: Defining conversation protocols from the coordination protocol
The set of simplification rules is defined directly from the coordination graph G=<A,N,O,V+,V-> as follows:
Example: x y t2 t1 z

11. Step 2: Defining conversation protocols from the coordination protocol
A conversation protocol is viewed as the set of conversations that are reduced to the axiom (built from the axiom x0) following the reduction R relation defined from the dependency-based coordination graph:
A conversation protocol defined on a role-cut d found in a dependency-based coordination graph; and an axiom x0 is defined as follows:

12. Simple Example

13. Simple Example
Is a sequence observed at the roles-cut a valid conversation?
YES
Semantics of this conversation
Is a valid conversation?
No, the partial order between x and y has been violated. There is no simplification rule that will remove this incorrect sequence. Thus, this expression will never be reduced to the axiom e0

14. Conclusions and future works
is valid(Coordination protocol) => is valid(Conversation protocol) <=> !is valid(Conversation protocol) => !is valid(Coordination protocol)
An external observer (the environment in MIC*) may check the consistency of coordination protocols by only observing messages exchanged at the roles-cut.
The agent’s autonomy axiom is still preserved!
Responsibility of an agent’s of being incoherent with its society norms is established by a trusted entity.
The presented work presented only an example of a formal link between the coordination protocol and its related conversation protocol. Still, it does not specify how to check efficiently the coherency of a conversation.
Checking the coherency of a conversation in a roles-cut is a hard-problem!
But, the incremental nature of a conversation between agents opens opportunities in order to check the consistency of a conversation incrementally:
Think about iterative compilers…
These works are under developments

15. References
[mal94]

17. =