## Introduction and MIC* static structure

Within the context of open systems, agents have to be considered as completely closed and unknown entities, which means that no assumption can be made on their internal architecture or intentions. Consequently, the study of agent deployment environments considers only the fundamental features of agents such as autonomy and interaction. Here we analyse what could be a general model of deployment environment without targeting any particular agent internal architecture.
Interaction among agents is independent from their internal architecture. In fact, agents build using different internal architecture and models should be able to interact in order to achieve their goals. Otherwise, the system is considered as closed to known agents developed locally by trusted software developers. Within multi-agent system the term interaction is misused in and often refers to communication. Communication is defined as exchanging information between several locations. To be exchanged, information is usually encoded using explicit interaction object, which carries it from a place to another. For instance, a researcher's ideas can be encoded as words and sentences in an explicit a scientific paper. Other human agents are able to read this interaction object and, depending on their competences, to decode the contained information. Once, the paper has been written and published, the emitting agent does not have a full control of the ongoing communication processes that occur. For instance, Socrates is still in a communication process with other human agents centuries after his death. Having this intuition about communication and interaction object, it would be interesting to look further in the structure of interaction objects. The first abstraction is to define an empty interaction object that carries no information. For instance, a randomly generated paper is an interaction object that may be submitted to an international conference. However, it does not carry any information except the fact that it is a sequence of words. Interaction objects can be composed formally to represent a group of interaction objects that occur simultaneously. For instance, the proceeding of the conference is an interaction object represented as an abstract sum of elementary interaction objects. Consequently, interaction objects have naturally a structure of a commutative monoid $(\Or,+)$ with a commutative composition law $+$ and a neutral element $0$. Consider now a situation where a poor-quality paper is rejected by the program comity of a conference and accepted by a national workshop community. This interaction object never reached perceptions of other agents in the first case and interacts with other agents in the second case. So, the interaction rules are defined contextually. This introduces the concept of \gimportant{interaction space}. Hence, the interaction space defines the context of the interaction laws among the interaction objects. Interaction spaces are defined within the deployment environment and do not depend on the deployed agents.
Agents are perceived in their deployment environment only through their interaction objects. An agent may be present in several interaction spaces: this defines its coordinate in the deployment environment. When agent is not present in a certain interaction space its representation is equal to the empty interaction object $0$. When this value changes, this is perceived as a 'movement' inside the interaction space. Therefore, the mobility of an agent can be then defined as the movement of its interaction objects among interaction spaces. In order to easily define this notion of mobility, it is necessary to define negative interaction objects. Hence, an agent moves outside an interaction space, when its representation is reduced to $0$. This can be expressed by $x-(x)=0$. So, negative interaction objects are defined formally as being objects that reduce other interaction objects under the composition law $+$. So, the interaction objects structure is no more a simple commutative monoid but a commutative group $(\Or,+)$.
To summarise, intuitively the concepts of a deployment environment are:
• Interaction objects defined as a commutative group $(\Or,+)$ encoding information exchanged among agents through interaction spaces.
• Interaction spaces, represented by $\Sr$, are active entities that define the interaction laws among interaction objects.
The structure of MIC* <I,O,M> can be viwed as the composition of two matrices I and O representing respectively the inbox matrix and the outbox matrix and the memory vector of agents. MIC* is interested only on the I and O matrices; the M vector is only supposed to exist. The rows of the O (and I) matrices represent the agents and the columns the interaction spaces. The content of the cell I[a,s] is interpreted as the inbox of the agent 'a' in the interaction space 's'; similarly O[a,s] represents the outbox of the agent 'a' in the interaction space 's'.

## MIC* dynamics

The previous section has presented the algebraic model MIC*. A MIC term is a instantaneous snapshot of the agent deployment environment state. The dynamical aspects of the deployment environment are represented by the set of applications among MIC* terms. Among these applications, it would be interesting to define some particular classes of applications that have a special semantics within the multi-agent systems framework:
• Interaction ($\phi$): From an external point of view, two agents are considered as interacting when the perceptions of an agent are influenced by the emissions of another one. Consequently, interaction evolutions should modify only the perceptions of agents according to the emissions of other agents within a defined interaction space.
• Movement ($\mu$): The mobility of an agent is defined as the mobility of its interaction objects among different interaction spaces. During a movement no interaction objects is created or lost. In fact, this is an interesting feature to prevent incoherent duplications by guaranteeing that an entity actually disappears from its original location and appears in its destination. Therefore, a movement switches only the places of the agent outboxes interaction spaces and leave them globally invariant.
• Computation ($\gamma$): Computation is an agent's internal process. The deployment environment is assumed to not have access to the internal structure of agents. The only way to observe that an agent has conducted a computation is when it changes autonomously its outboxes within interaction spaces. To avoid confusion between computation and movement, after a computation, agents conserve their presence. In other words, an agent is not allowed to appear (respectively to disappear) suddenly in an interaction space when it was not present (respectively present) before the computation.
The dynamics of the environment is viwed as an infinite repetition of these evolution rules: Movement, Interaction, anc Computation or {M,I,C}* (star for an infinite repetition).

## MIC* Simple Applet

Description of the applet:

• Left: moves the user agent to the left in the virtual space;
• Right: moves the user agent to the right in the virtual space;
• Up: moves the user agent up in the virtual space;
• Down: moves the user agent down in the virtual space;
• UA Interaction: calculate the result of the interaction of the user agent with other agents in the interaction spaces;
• CA Interaction: calculate the result of the interaction of the computing agents (+,*,-,/) with other agents in the interaction spaces;
• CA Computation: calculate the computation of the computing agents (+,*,-,/) according to their inbox;
• UA Computation: emit the interaction objects in the environment;
• Get UA Inbox: retreive the inbox of the user agent from the environment.
Interaction Rules:
• For all interaction spaces excepts '(/)space', 's' interacts with any interaction object of type {i,j} where i and j are integers;
• '(/)space' defines a specific interaction rule: 's' interacts with any interaction object of type {i,j} where j is different from 0;
• For all interaction spaces 'c' interacts with any integer;

Example: calculate this expression: (3+7)/2

1. set the user agent registers r1 r2 to 3 and 7
2. make a user agent computation using UA Computation button
3. move your agent to 'CA:x+y' interaction space
4. make the computation agent perceive your interaction objects by using the 'CA Interaction' button
5. now that the '+' computation agent has perceived your interaction object make him computing by using the 'CA Computation' button
6. now you have to perceive the result of the computation; so you have to calculate the interaction of your agent; this is done by using the 'UA Interaction' button
7. you should have the reslut of (3+7) in your inbox in the MIC* environment; to get this inbox use the 'Get UA Inbox' button
8. now copy this value in the resigters with the next value to calculate (which is 2) so r1=10 r2=2 for instance
9. do the same steps, but this time you have to go into the '(/)space' interaction space.

Now that you have a little experience with the concepts of MIC* ,) try to calculate this expression: 1/0. For this, you have to entre the "(/)-space" and interact with the division agent. You will see that this never perceive the {1,0} interaction object! So, the rules of interactions defined in the interaction space have prevent the divion agent from raising a division by zero error. Thanks to the decoupling of the interaction and the computation; autonomous agents may be protected from interactions that challege the 'norms' or the 'rules'.