¹¹institutetext: Zhejiang University, Hangzhou, Zhejiang Province, China
¹¹email: {luojieting,baiseliao}@zju.edu.cn ²²institutetext: Utrecht University, Utrecht, the Netherlands
²²email: J.J.C.Meyer@uu.nl

A Formal Framework for Reasoning about Agents’ Independence in Self-organizing Multi-agent Systems

Jieting Luo 11 Beishui Liao 11 John-Jules Meyer 22

Abstract

Self-organization is a process where a stable pattern is formed by the cooperative behavior between parts of an initially disordered system without external control or influence. It has been introduced to multi-agent systems as an internal control process or mechanism to solve difficult problems spontaneously. However, because a self-organizing multi-agent system has autonomous agents and local interactions between them, it is difficult to predict the behavior of the system from the behavior of the local agents we design. This paper proposes a logic-based framework of self-organizing multi-agent systems, where agents interact with each other by following their prescribed local rules. The dependence relation between coalitions of agents regarding their contributions to the global behavior of the system is reasoned about from the structural and semantic perspectives. We show that the computational complexity of verifying such a self-organizing multi-agent system is in exponential time. We then combine our framework with graph theory to decompose a system into different coalitions located in different layers, which allows us to verify agents’ full contributions more efficiently. The resulting information about agents’ full contributions allows us to understand the complex link between local agent behavior and system level behavior in a self-organizing multi-agent system. Finally, we show how we can use our framework to model a constraint satisfaction problem.

Keywords:

Self-organization, logic, Multi-agent Systems, Graph Theory, Verification

1 Introduction

In the modern society artificial intelligence has been applied in many industries such as health care, retail and traffic. Since our nature presents beautiful ways of solving problems to us, biological insights have been the source of inspiration for the development of several techniques and methods to solve complex engineering problems. One of the examples is the adoption of self-organization from complex systems. Self-organization is a process where a stable pattern is formed by the cooperative behavior between parts of an initially disordered system without external control or influence. It has been introduced to multi-agent systems as an internal control process or mechanism to solve difficult problems spontaneously, especially if the system is operated in an open environment thereby having no perfect and a priori design to be guaranteed [28][25][27]. One typical example using self organization mechanisms is ant colony optimization [13], where ants collaborate to find out the optimal solution through laying down pheromone trails. In a wireless mobile sensor network, robots with sensors can deploy themselves to achieve optimal sensing coverage when the system designer is not aware of robots’ interest or the operated environment [18].

However, making a self-organizing system is highly challenging [17][32]. The traditional development of a multi-agent system is a top-down process which starts from the specification of the goal that the system needs to achieve to the development of specific agents. In this way, the goal of the system will guarantee to be achieved if the specific agents are implemented successfully. As the hierarchical in Figure.1(left), the global objective can be achieved by modules E and F, and module E can be refined by agents A and B and module F can be refined by agents B, C and D. However, such an approach cannot be applied to the development of self-organizing multi-agent systems: because a self-organizing multi-agent system has autonomous agents and local interactions between them, the development of a self-organizing multi-agent system is usually a bottom-up process which starts from defining local components to examining global behavior. The distributive structure in Figure.1(right) represents a self-organizing multi-agent system, where agents A, B, C and D interact with each other. Because of that, it is difficult to predict the behavior of the system from the system specification about autonomous agents and local interactions between them. Consequently, a self-organizing multi-agent system is usually evaluated through implementation. In other words, the complex link between local agent behavior and system level behavior in a self-organizing multi-agent system makes implementation the usual way of correctness evaluation. There have been some methodologies for developing self-organizing multi-agent systems (such as ADELFE [3][4]), but they do not explain the complex link between local agent behavior and system level behavior of a self-organizing multi-agent system. The community of Self-Adaptive and Self-Organizing Systems (SASO) also highlights that it is still challenging to investigate how micro-level behavior lead to desirable macro-level outcomes. What if we can understand the complex link between micro-level agent behavior and macro-level system behavior in a self-organizing multi-agent system? If there is approach available that helps us understand how global system behavior emerges from agents’ local interactions, the development of self-organizing multi-agent systems can be facilitated. For example, if we know a coalition of agents brings about a property independently and we want to change that property, what we have to do is to reconfigure the behavior of that coalition instead of the behavior of agents outside that coalition. As we can see, the independent relation between coalitions of agents in self-organizing multi-agent systems is an crucial issue to be investigated.

Refer to caption — Figure 1: A comparison between top-down approach (left) and bottom-up approach (right).

In theoretical computer science, logic has been used for proving the correctness of a system [11][10]. Instead of implementing the system with respect to a specification, we can verify whether the system specification fulfills the global objective by checking logical formulas. That indeed provides a new way of evaluating a self-organizing multi-agent system apart from implementation. In this paper, we propose a logic-based framework of self-organizing multi-agent systems, where agents interact with each other by following their prescribed local rules. Based on the local rules, we define a structural property called independent component, a coalition of agents which do not get input from agents outside the coalition. Our semantics and the structure derived from communication between agents allow us not only to verify behavior of the system, but also to reason about the independence relation between coalitions of agents regarding their contributions to the global system behavior from two perspectives. Moreover, we propose a layered approach to decompose a self-organizing multi-agent system into different coalitions, which allows us to check agents’ full contributions more efficiently. The resulting information about agents’ full contributions allows us to understand the complex link between local agent behavior and system level behavior in a self-organizing multi-agent system. We finally show how we can use our framework to model a constraint satisfaction problem, where a solution based on self-organization is used.

The rest of the paper is organized as follows: Section 2 introduces the abstract framework to represent a self-organizing multi-agent system, proposing the notion of independent components; Section 3 provides the semantics of our framework to reason about agents’ independence in terms of their contributions to the global behavior of the system; the model-checking problem is investigated in Section 4; Section 5 proposes a layered approach to decompose a self-organizing multi-agent system; in Section 6 we show how to use our framework to model constraint satisfaction problems; finally, related work and conclusion are provided in Sections 7 and 8 respectively.

2 Abstract Framework

In this section, we will propose the model of this paper: a concurrent game structure extended with local rules and define the structural property of independent components whose behavior is independent on the behavior of the agents outside of the components.

2.1 Self-organizing Multi-agent Systems

The semantic structure of this paper is concurrent game structures (CGSs). It is basically a model where agents can simultaneously choose actions that collectively bring the system from the current state to a successor state. Compared to other kripke models of transaction systems, each transition in a CGS is labeled with collective actions and the agents who perform those actions. Moreover, we treat actions as first-class entities instead of using choices that are identified by their possible outcomes. Formally,

Definition 2.1

A concurrent game structure is a tuple $\mathcal{S}=(k,Q,\pi,\Pi,ACT,d,\delta)$ such that:

•

A natural number $k\geq 1$ of agents, and the set of all agents is $\Sigma=\{1,\ldots,k\}$ ; we use $A$ to denote a coalition of agents $A\subseteq\Sigma$ ;
•

A finite set $Q$ of states;
•

A finite set $\Pi$ of propositions;
•

A labeling function $\pi$ which maps each state $q\in Q$ to a subset of propositions which are true at $q$ ; thus, for each $q\in Q$ we have $\pi(q)\subseteq\Pi$ ;
•

A finite set $ACT$ of actions;
•

For each agent $i\in\Sigma$ and a state $q\in Q$ , $d_{i}(q)\subseteq ACT$ is the non-empty set of actions available to agent $i$ in $q$ ; $D(q)=d_{1}(q)\times\ldots\times d_{k}(q)$ is the set of joint actions in $q$ ; given a state $q\in Q$ , an action vector is a tuple $\langle\alpha_{1},\ldots,\alpha_{k}\rangle$ such that $\alpha_{i}\in d_{i}(q)$ ;
•

A function $\delta$ which maps each state $q\in Q$ and a joint action $\langle\alpha_{1},\ldots,\alpha_{k}\rangle\in D(q)$ to another state that results from state $q$ if each agent adopted the action in the action vector, thus for each $q\in Q$ and each $\langle\alpha_{1},\ldots,\alpha_{k}\rangle\in D(q)$ we have $\delta(q,\langle\alpha_{1},\ldots,\alpha_{k}\rangle)\in Q$ .

Note that the model is deterministic: the same update function adopted in the same state will always result in the same resulting state. A computation over $\mathcal{S}$ is an infinite sequence $\lambda=q_{0},q_{1},q_{2},\ldots$ of states such that for all positions $i\geq 0$ , there is a joint action $\langle\alpha_{1},\ldots,\alpha_{k}\rangle\in D(q_{i})$ such that $\delta(q_{i},\langle\alpha_{1},\ldots,\alpha_{k}\rangle)=q_{i+1}$ . For a computation $\lambda$ and a position $i\geq 0$ , we use $\lambda[i]$ to denote the $i$ th state of $\lambda$ . More elaboration of concurrent game structures can be found in [2].

Self-organization has been introduced into multi-agent systems for a long time to solve various problems in multi-agent systems [32][16]. It is a mechanism or a process which enables a system to finish a difficult task by the cooperative behavior between agents spontaneously [12]. In particular, agents in a self-organizing multi-agent system have local view of the system and the system reaches a desired state spontaneously without guided by any externals. In this paper, we argue that the cooperative behavior is guided by prescribed local rules that agents are supposed to follow with communication between agents as a prerequisite. Therefore, we can define a self-organizing multi-agent system as a concurrent game structure together with a set of local rules for agents to follow. For example, in ant colony optimization algorithms, ants are required to record their positions and the quality of their solutions (lay down pheromones) so that in later simulation iterations more ants locate better solutions. Before defining such a type of local rules, we first define what to communicate, which is given by an internal function.

Definition 2.2 (Internal Functions)

Given a concurrent game structure $\mathcal{S}$ , the internal function of an agent $i$ is a function $m_{i}:Q\to\mathcal{L}_{prop}$ that maps a state $q\in Q$ to a propositional formula over $\pi(q)$ .

The internal function returns the information that is provided by participating agents themselves at a given state and might be different from agent to agent. Depending on the application, we might have different interpretation on $m_{i}(q)$ . For example, vehicles in a busy traffic situation are required to communicate their urgencies, and robots sensors in a self-deploy sensing network are required to communicate their sensing areas. Here we assume that agents are wise enough to process their local rules with the communicated information. A local rule is defined based on agents’ communication as follows:

Definition 2.3 (Abstract Local Rules)

Given a concurrent game structure $\mathcal{S}$ , an abstract local rule for an agent $a$ is a tuple $\langle\tau_{a},\gamma_{a}\rangle$ consisting of a function $\tau_{a}(q)$ that maps a state $q\in Q$ to a subset of agents, that is, $\tau_{a}(q)\subseteq\Sigma$ , and a function $\gamma_{a}(M(q))$ that maps $M(q)=\{m_{i}(q)\mid i\in\tau_{a}(q)\}$ to an action available in state $q$ to agent $a$ , that is, $\gamma_{a}(M(q))\in d_{a}(q)$ . We denote the set of all the abstract local rules as $\Gamma$ and a subset of abstract local rules as $\Gamma_{A}$ that are designed for coalition of agents $A$ .

An abstract local rule consists of two parts: the first part $\tau_{a}(q)$ states the agents with whom agent $a$ is supposed to communicate in state $q$ , and the second part $\gamma_{a}$ states the action that agent $a$ is supposed to take given the communication result with agents in $\tau_{a}(q)$ for their internals. Moreover, in [2] and [19], a rule (or a norm) is defined as a mapping $\gamma(q)$ that explicitly prescribes what agents need to do in a given state, which requires that system designers have complete information of the system including agents’ internals such that the desired state as well as the legal computations can be identified. Differently, a local rule in this paper is defined based on agents’ communication. Different participating agents might have different internal functions, making the communication results and thus the actions that are required to take different. Hence, the system allows agents to find out the desired state and how to get there in a self-organizing way. We see local rules not only as constraints but also guidance on agents’ behavior, namely an agent does not know what to do if he does not communicate with other agents. Therefore, we exclude the case where agents get no constraint from their respective local rules. Notation $out$ denotes a set of computations and $out(q,\Gamma_{A})$ is the set of computations starting from state $q$ where agents in coalition $A$ follow their respective local rules in $\Gamma_{A}$ . A computation $\lambda=q_{0},q_{1},q_{2},...$ is in $out(q_{0},\Gamma_{A})$ if and only if it holds that for all positions $i\geq 0$ there is a move vector $\langle\alpha_{1},\ldots,\alpha_{k}\rangle\in D(\lambda[i])$ such that $\delta(\lambda[i],\langle\alpha_{1},\ldots,\alpha_{k}\rangle)=\lambda[i+1]$ and for all $a\in A$ it is the case that $\alpha_{a}=\gamma_{a}(M(q))$ . Because function $\gamma_{a}$ returns only an action that agent $a$ is allowed to take in any state, there will be only one computation in the set of computations $out(q,\Gamma_{\Sigma})$ , which will be denoted as $\lambda^{*}(q)$ without the curly brackets outside in the rest of the paper. Now we are ready to define a self-organizing multi-agent system. Formally,

Definition 2.4 (Self-organizing Multi-agent Systems)

A self-organizing multi-agent system (SOMAS) is a tuple $(\mathcal{S},\Gamma)$ , where $\mathcal{S}$ is a concurrent game structure and $\Gamma$ is a set of local rules for agents in the system to follow.

We will use the example in [29] for better understanding the above definitions.

Example 1

We consider a CGS scenario as Fig.2 where there are two trains, each controlled by an agent, going through a tunnel from the opposite side. The tunnel has only room for one train, and the agents can either wait or go. Starting from state $q_{0}$ , if the agents choose to go simultaneously, the trains will crash, which is state $q_{4}$ ; if one agent goes and the other waits, they can both successfully go through the tunnel without crashing, which is $q_{3}$ .

Local rules $\langle\tau_{1},\gamma_{1}\rangle$ and $\langle\tau_{2},\gamma_{2}\rangle$ are prescribed for the agents to follow: both agents communicate with each other for their urgency $u_{1}$ and $u_{2}$ in state $q_{0}$ ; the one who is more urgent can go through the tunnel first and the other one has to wait for it; after $q_{0}$ the agent who waits can go. We formalize as follows. In state $q_{0}$ , $\tau_{1}(q_{0})=\{a_{1},a_{2}\}$ and $\tau_{2}(q_{0})=\{a_{1},a_{2}\}$ ,

\gamma_{1}(u_{1},u_{2})=\left\{\begin{array}[]{ll}go&\mbox{if $a_{1}$ is more urgent than or}\\ &\mbox{as urgent as $a_{2}$};\\ wait&\mbox{otherwise}.\end{array}\right.

\gamma_{2}(u_{1},u_{2})=\left\{\begin{array}[]{ll}go&\mbox{if $a_{1}$ is less urgent than $a_{2}$};\\ wait&\mbox{otherwise}.\end{array}\right.

In state $q_{1}$ and $q_{2}$ , $\tau_{1}(q_{1})=\{a_{1}\}$ and $\tau_{2}(q_{2})=\{a_{2}\}$ , and

\gamma_{1}(u_{1})=go,\quad\gamma_{2}(u_{2})=go.

Given the above local rules, if $a_{1}$ is more urgent than or as urgent as $a_{2}$ w.r.t. $u_{1}$ and $u_{2}$ , the desired state $q_{3}$ is reached along with computation $q_{0},q_{2},q_{3}\ldots$ ; if $a_{1}$ is less urgent than $a_{2}$ w.r.t. $u_{1}$ and $u_{2}$ , the desired state $q_{3}$ is reached along with computation $q_{0},q_{1},q_{3}\ldots$ . As we can see, any legal computation is not prescribed by system designers, because it depends on the urgencies that are provided by agents themselves. Instead, the agents can find out how to get to the desire state $q_{3}$ by themselves through following their local rules. Certainly, agents can collaborate to cross the tunnel successfully without communication, but that requires an external who is aware of the available actions for each train and the game structure to make a plan for them, which is not allowed in a self-organizing multi-agent system. In a self-organizing multi-agent system, each train does not know the available actions from the other train but it can follow its local rule to behave based on the communication result instead of listening to an external to behave.

2.2 Full Contribution

Similar to ATL [2], our language ATL- $\Gamma$ is interpreted over a concurrent game structure $\mathcal{S}$ that has the same propositions and agents. It is an extension of classical propositional logic with temporal cooperation modalities and path quantifiers. A formula of the form $\langle A\rangle\psi$ means that coalition of agents $A$ will bring about the subformula $\psi$ by following their respective local rules in $\Gamma_{A}$ , no matter what agents in $\Sigma\backslash A$ do, where $\psi$ is a temporal formula of the form $\bigcirc\varphi$ , $\Box\varphi$ or $\varphi_{1}\mathcal{U}\varphi_{2}$ (where $\varphi$ , $\varphi_{1}$ , $\varphi_{2}$ are again formulas in our language). Formally, the grammar of our language is defined below, where $p\in\Pi$ and $A\subseteq\Sigma$ :

\varphi::=p\mid\lnot\varphi\mid\varphi_{1}\land\varphi_{2}\mid\langle A\rangle\bigcirc\varphi\mid\langle A\rangle\Box\varphi\mid\langle A\rangle\varphi_{1}\mathcal{U}\varphi_{2}\hskip 14.22636pt

Given a self-organizing multi-agent system $(\mathcal{S},\Gamma)$ , where $\mathcal{S}$ is a concurrent game structure and $\Gamma$ is a set of local rules, and a state $q\in Q$ , we define the semantics with respect to the satisfaction relation $\models$ inductively as follows:

•

$\mathcal{S},\Gamma,q\models p$ iff $p\in\pi(q)$ ;
•

$\mathcal{S},\Gamma,q\models\lnot\varphi$ iff $\mathcal{S},\Gamma,q\not\models\varphi$ ;
•

$\mathcal{S},\Gamma,q\models\varphi_{1}\land\varphi_{2}$ iff $\mathcal{S},\Gamma,q\models\varphi_{1}$ and $\mathcal{S},\Gamma,q\models\varphi_{2}$ ;
•

$\mathcal{S},\Gamma,q\models\langle A\rangle\bigcirc\varphi$ iff for all $\lambda\in out(q,\Gamma_{A})$ , we have $\mathcal{S},\Gamma,\lambda[1]\models\varphi$ ;
•

$\mathcal{S},\Gamma,q\models\langle A\rangle\Box\varphi$ iff for all $\lambda\in out(q,\Gamma_{A})$ and all positions $i\geq 0$ it holds that $\mathcal{S},\Gamma,\lambda[i]\models\varphi$ ;
•

$\mathcal{S},\Gamma,q\models\langle A\rangle\varphi_{1}\mathcal{U}\varphi_{2}$ iff for all $\lambda\in out(q,\Gamma_{A})$ there exists a position $i\geq 0$ such that for all positions $0\leq j\leq i$ it holds that $\mathcal{S},\Gamma,\lambda[j]\models\varphi_{1}$ and $\mathcal{S},\Gamma,\lambda[i]\models\varphi_{2}$ .

Dually, we write $\langle A\rangle\Diamond\varphi$ for $\langle A\rangle\top\mathcal{U}\varphi$ . Importantly, when we say a coalition of agents ensures a temporal formula by following their respective local rules, it means that agents in the coalition ensure a temporal formula if they take the actions that their local rules return, no matter whether agents outside of the coalition take the actions that are allowed to take or not. It is merely interpreted from our semantics, while agents’ dependence relation in terms of communication does not play a role.

Proposition 2.1

Given an SOMAS $(\mathcal{S},\Gamma)$ and a coalition $A$ , for any coalition $A^{\prime}\supseteq A$ , it holds that

\mathcal{S},\Gamma,q\models\langle A\rangle\psi\Rightarrow\mathcal{S},\Gamma,q\models\langle A^{\prime}\rangle\psi,

Proof

Because $A\subseteq A^{\prime}$ , computation set $out(q,\Gamma_{A^{\prime}})\subseteq out(q,\Gamma_{A})$ . Thus, if $\mathcal{S},\Gamma,q\models\langle A\rangle\psi$ , meaning that $\psi$ holds in all $\lambda\in out(q,\Gamma_{A})$ , then $\psi$ will also hold in all $\lambda\in out(q,\Gamma_{A^{\prime}})$ . Therefore, $\mathcal{S},\Gamma,q\models\langle A^{\prime}\rangle\psi$ .

It means if a coalition ensures an temporal formula, then any coalition that contains that coalition will also ensure that temporal formula. Notice that $A^{\prime}$ can be the whole agent set $\Sigma$ .

Example 2

According to the local rules in the two-train example, the train who is more urgent can go through the tunnel first and the other one has to wait for him. We have that one train by itself cannot bring about the result of passing through the tunnel without crash through following the local rule, which can be expressed:

\mathcal{S},\Gamma,q_{0}\not\models\langle a_{1}\rangle\Diamond\text{passed},

\mathcal{S},\Gamma,q_{0}\not\models\langle a_{2}\rangle\Diamond\text{passed}.

Instead, both trains have to cooperate to bring about the result. Thus, we have that both agents by themselves can bring about the result of passing through the tunnel without crash through following the local rules, which can be expressed:

\mathcal{S},\Gamma,q_{0}\models\langle a_{1},a_{2}\rangle\Diamond\text{passed}.

As we mentioned in the introduction, because a self-organizing multi-agent system has autonomous agents and local interactions between them, we are not clear about how the local components lead to the global behavior of the system, making a self-organizing multi-agent system usually evaluated through implementation. One possible solution to understand the complex link between local agent behavior and system level behavior is to divide the system into components, each of which has contribution to the global behavior of the system and is independent on agents outside the coalition. The principle is that, when studying the behavior of one component, we do not need to think about the influences coming from agents outside the component. The independence between different components in terms of their contributions to the global behavior of the system allows us to understand the complex link. With this idea, we first define a notion of independent components over a self-organizing multi-agent system.

Definition 2.5 (Independent Components)

Given an SOMAS $(\mathcal{S},\Gamma)$ , a coalition of agents $A$ is an independent component w.r.t. a state $q$ iff for all $a\in A$ and its abstract local rule $\langle\tau_{a},\gamma_{a}\rangle$ it is the case that $\tau_{a}(q)\subseteq A$ ; a coalition of agents $A$ is an independent component w.r.t. a set of computations $out$ iff for all $\lambda\in out$ and $q\in\lambda$ $A$ is an independent component w.r.t. state $q$ .

An independent component w.r.t. state $q$ is a coalition of agents $A$ which only gets input information from agents inside coalition $A$ in state $q$ . In other words, an independent component might output information to agents in $\Sigma\backslash A$ , but never get input from agents in $\Sigma\backslash A$ .

Proposition 2.2

Given an SOMAS $(\mathcal{S},\Gamma)$ and two coalitions $A$ and $B$ where $A\cap B\not=\emptyset$ , if both $A$ and $B$ are independent components, then $A\cap B$ is also an independent component.

Proof

Because $A$ is an independent component and $A\cap B\subseteq A$ , agents in $A\cap B$ do not get input from agents in $\Sigma\backslash A$ . For the same reason, agents in $A\cap B$ do not get input from agents in $\Sigma\backslash B$ . Thus, agents in $A\cap B$ do not get input from agents in $(\Sigma\backslash A)\cup(\Sigma\backslash B)=\Sigma\backslash(A\cap B)$ . Therefore, $A\cap B$ is also an independent component.

Example 3

In the two-train example, as in state $q_{0}$ both trains need to communicate with each other as their local rules require, neither $a_{1}$ nor $a_{2}$ is an independent component w.r.t. state $q_{0}$ . Because the system only consists of two trains, the two trains form an independent component w.r.t. state $q_{0}$ . Because in states $q_{1}$ and $q_{2}$ each train only gets urgency from itself to go ahead, $a_{1}$ is an independent component w.r.t. state $q_{1}$ and $a_{2}$ is an independent component w.r.t. state $q_{2}$ .

Using the notion of independent components and our language, We then propose the notion of semantic independence, structural independence and full contribution to characterize the independence between agents from different perspectives.

Definition 2.6 (Semantic Independence, Structural Independence and Full Contribution)

Given an SOMAS $(\mathcal{S},\Gamma)$ , a coalition of agents $A$ and a state $q$ ,

•

$A$ is semantically independent with respect to a temporal formula $\psi$ from $q$ iff $\mathcal{S},M,\Gamma,q\models\langle A\rangle\psi$ ;
•

$A$ is structurally independent from $q$ iff $A$ is an independent component w.r.t. the set of computations $out(q,\Gamma_{A})$ ;
•

$A$ has full contribution to $\psi$ in $q$ iff $A$ is the minimal (w.r.t. set-inclusion) coalition that is both semantically independent with respect to $\psi$ and structurally independent from $q$ .

The notion of full contribution captures the property of coalition $A$ in terms of independence from two different perspectives: semantically, coalition $A$ ensures $\psi$ through following its local rules no matter what other agents do; structurally, coalition $A$ do not communicate with other agents when following its local rules no matter what other agents do. Notice that when we say coalition $A$ has full contribution to $\psi$ in $q$ , it is important for coalition $A$ to be the minimal coalition that is both semantically independent with respect to $\psi$ and structurally independent from state $q$ . This is because there might exist multiple coalitions that are both semantically independent with respect to $\psi$ and structurally independent from state $q$ and the set of all agents $\Sigma$ is apparently one of them. In other words, coalition $A$ has full contribution to $\psi$ because any subset of coalition $A$ is either semantically dependent with respect to $\psi$ or structurally dependent. The following example illustrates why we need both semantic independence and structural independence to characterize the full contribution of a coalition of agents.

Example 4

Consider the transition system in Fig.3(top). $\langle\alpha,*\rangle$ is interpreted as an action vector where agent $a_{1}$ performs action $\alpha$ and agent $a_{2}$ does whatever he can. Local rules are prescribed for agents $a_{1}$ and $a_{2}$ : in state $q_{0}$ $a_{1}$ needs to communicate with $a_{2}$ for some valuable information and is supposed to do $\alpha$ based on the communication result. As we can see from the structure, $a_{1}$ brings about $p$ no matter what $a_{2}$ does, which means that coalition $\{a_{1}\}$ is semantically independent. However, since $a_{1}$ needs to communicate with $a_{2}$ in state $q_{0}$ , coalition $\{a_{1}\}$ is not structurally independent.

Consider the transition system in Fig.3(down). $\langle\alpha,*\backslash\alpha\rangle$ is interpreted as an action vector where agent $a_{1}$ performs action $\alpha$ and agent $a_{2}$ deviates from action $\alpha$ . Similar for $\langle*\backslash\alpha,\alpha\rangle$ . Local rules are prescribed for agents $a_{1}$ and $a_{2}$ : in state $q_{0}$ , both agents do not need to communicate with each other and are supposed to do $\alpha$ . As we can see from the structure, $a_{1}$ and $a_{2}$ can bring about $p$ through following their local rules but neither $a_{1}$ nor $a_{2}$ can achieve that by itself, which means that coalitions $\{a_{1}\}$ or $\{a_{2}\}$ is not semantically independent. But since they do not need to communicate with each other, it is structurally independent.

As for the two-train example, neither train, namely $a_{1}$ or $a_{2}$ as a coalition, has full contribution to the result of passing through the tunnel without crash. The reasons are listed as follows: any single train cannot ensure the result of passing through the tunnel without crash, which means that any single train is not semantically independent. Moreover, both trains follow their local rules to communicate with each other in state $q_{0}$ , which means that any single train is not an independent component w.r.t. state $q_{0}$ thus not being structurally independent.

The two trains have full contribution to the result of passing through the tunnel without crash, because both agents by themselves can bring about the result of passing through the tunnel without crash through following the local rules, and the coalition of two trains is obviously an independent component w.r.t. $out(q_{0},\Gamma_{\{a_{1},a_{2}\}})$ , which means that it is structurally independent, and the coalition of two trains is obviously the minimal coalition that is both semantically independent w.r.t. the result of no crash and structurally independent from state $q_{0}$ .

Proposition 2.3

Given an SOMAS $(\mathcal{S},M,\Gamma)$ , a state $q$ and a temporal formula $\psi$ , there does not exist two different coalitions $A$ and $B$ such that $A\cap B\not=\emptyset$ and both $A$ and $B$ has full contribution to $\psi$ in $q$ .

Proof

Suppose there exists two different coalitions $A$ and $B$ that have full contribution to $\psi$ , which means that both $A$ and $B$ are the minimal (w.r.t. set-inclusion) coalitions that are both semantically independent with respect to $\psi$ and structurally independent from $q$ . Because $\mathcal{S},M,\Gamma,q\models\langle A\rangle\psi$ and $\mathcal{S},M,\Gamma,q\models\langle B\rangle\psi$ , we have $\mathcal{S},M,\Gamma,q\models\langle A\cap B\rangle\psi$ . Because $A\cap B\not=\emptyset$ and both $A$ and $B$ are independent components, we have $A\cap B$ is also an independent component. Therefore, $A\cap B$ is both semantically independent with respect to $\psi$ and structurally independent from $q$ . If $A\cap B\subset A$ , $A$ is not the minimal (w.r.t. set-inclusion) coalition that is both semantically independent with respect to $\psi$ and structurally independent from $q$ . If $A\cap B=A$ , which means that $A\subset B$ , then $A$ , not $B$ , is the minimal (w.r.t. set-inclusion) coalition that is both semantically independent with respect to $\psi$ and structurally independent from $q$ . Contradiction!

The above proposition is consistent with an intuition: when semantically coalition $A$ ensures $\psi$ through following local rules but $A$ is not structurally independent from $q$ , meaning that agents in $A$ need to communicate with agents outside $A$ to ensure $\psi$ , we will enlarge the coalition through including the agents with which agents from $A$ communicate. The resulting coalition is the minimal (w.r.t. set-inclusion) coalition that is both semantically independent with respect to $\psi$ and structurally independent from $q$ , which is also unique.

3 Model Checking

Our logic-based framework provides us another approach to verify a self-organizing multi-agent system. If we only care about whether the system will bring about a property, we only need to check whether a formula in ATL- $\Gamma$ with the whole set of agents is satisfied in a certain state; if we want to know whether a coalition of agents will bring about a property independently, we need to check whether a coalition of agents has full contribution to a temporal formula in a certain state. In this section, we will investigate how difficult to answer these two model-checking problems. We first measure the model-checking problem for ATL- $\Gamma$ . In order to answer that, we extend our concurrent game structure $\mathcal{S}$ by adding new propositions to states that indicate for each local rule $\langle\tau_{a},\gamma_{a}\rangle\in\Gamma$ , whether or not it is followed by a corresponding agent. For this purpose, we define the extended game structure $\mathcal{S}^{F}=(k,Q^{F},\pi^{F},\Pi^{F},ACT,d^{F},\delta^{F})$ as follows:

•

$Q^{F}=\{\langle\bot,q\rangle\mid q\in Q\}\cup\{\langle q^{\prime},q\rangle\mid q^{\prime},q\in Q\text{ and }q\text{ is a successor of }q^{\prime}\text{ in }\mathcal{S}\}$ . In other words, a state of the form $\langle\bot,q\rangle$ of $\mathcal{S}^{F}$ corresponds to the game structure $\mathcal{S}$ being in state $q$ at the beginning of a computation, and a state of the form $\langle q^{\prime},q\rangle$ corresponds to $\mathcal{S}$ being in state $q$ during a computation whose previous state was $q^{\prime}$ .
•

For each agent $a\in\Sigma$ , there is a new proposition followed; that is $\Pi^{F}=\Pi\cup\{followed_{a}\mid a\in\Sigma\}$ .

•

For each state of the form $\langle\bot,q\rangle\in Q^{F}$ , we have $\pi^{F}(\langle\bot,q\rangle)=\pi(q)$ ; For each state $\langle q^{\prime},q\rangle\in Q^{F}$ , we have

	$\displaystyle\pi^{F}(\langle q^{\prime},q\rangle)=$	$\displaystyle\pi(q)\cup\{followed_{a}\mid\text{ there is a move vector }\langle\alpha_{1},\ldots,\alpha_{k}\rangle\in D(q^{\prime})$
		$\displaystyle\text{such that }\delta(q^{\prime},\langle\alpha_{1},\ldots,\alpha_{k}\rangle)=q\text{ and }\alpha_{a}\in\gamma_{a}(M(q)).\}$

•

For each player $\alpha\in\Sigma$ and each state $\langle\cdot,q\rangle\in Q^{F}$ , we have $d^{F}_{\alpha}(\langle\cdot,q\rangle)=d_{a}(q)$ ;
•

For each state $\langle\cdot,q\rangle\in Q^{F}$ and each move vector $\langle\alpha_{1},\ldots,\alpha_{k}\rangle\in D(q)$ , we have $\delta^{F}(\langle\cdot,q\rangle,\langle\alpha_{1},\ldots,\alpha_{k}\rangle)=\delta(q,\langle\alpha_{1},\ldots,\alpha_{k}\rangle)$ .

That is how we transfer $\mathcal{S}$ to $\mathcal{S}^{F}$ , and one computation in $\mathcal{S}$ corresponds to one computation in $\mathcal{S}^{F}$ . The new propositions $\{followed_{a}\mid a\in\Sigma\}$ allow us to identify the computations that follow the local rules. Using $\mathcal{S}^{F}$ , we encode agents’ following of local rules as propositions in the states. Therefore, evaluating formulas of the form $\langle A\rangle\psi$ over states of $\mathcal{S}$ can be reduced to evaluating standard ATL formulas over states of $\mathcal{S}^{F}$ . In classic ATL [2], a formula of the form $\llangle A\rrangle\psi$ means there exists a set $F_{A}$ of strategies, one for each player in $A$ , to bring about $\psi$ , which can be interpreted as agents’ capacity of bringing about a property and is different from the semantics of $\langle A\rangle\psi$ in this paper. Namely, given a SOMAS $(\mathcal{S},\Gamma)$ , a state $q$ and a set of agents $A$ , a formula $\mathcal{S},\Gamma,q\models\langle A\rangle\psi$ holds iff the state $\langle\bot,q\rangle$ of the extended game structure $\mathcal{S}^{F}$ satisfies the following ATL^∗ formula:

\llangle A\rrangle(\bigwedge_{a\in A}\Box followed_{a}\land\psi).

As we can see, even though coalition of agents $A$ has the capacity to bring about $\psi$ , formula $\mathcal{S},\Gamma,q\models\langle A\rangle\psi$ does not necessarily hold, because coalition $A$ has to follow its local rules to achieve that. To see why, consider the two-train example.

Example 5

Suppose we change the local rules to be the following:

\gamma_{1}(u_{1},u_{2})=\left\{\begin{array}[]{ll}go&\mbox{if $a_{1}$ is more urgent than $a_{2}$};\\ wait&\mbox{otherwise}.\end{array}\right.

\gamma_{2}(u_{1},u_{2})=\left\{\begin{array}[]{ll}go&\mbox{if $a_{1}$ is less urgent than $a_{2}$};\\ wait&\mbox{otherwise}.\end{array}\right.

When both trains have the same urgency, it will result in deadlock instead of passing through the tunnel if both trains follow their local rules to wait, which can be expressed in

\mathcal{S},\Gamma,q_{0}\not\models\langle a_{1},a_{2}\rangle\Diamond\text{passed}.

\mathcal{S},\Gamma,q_{0}\models\langle a_{1},a_{2}\rangle\Diamond\text{deadlock}.

However, it is clear that both trains can cooperate to pass through the tunnel without crash, which can be expressed in

\mathcal{S},q_{0}\models\llangle a_{1},a_{2}\rrangle\Diamond\text{passed}.

Although checking an ATL- ${\Gamma}$ formula can be reduced to checking a logically equivalent ATL^∗ formula, it still can be done in an efficient way so that the corresponding complexity bounds are much lower than those for general ATL^∗ model checking.

Proposition 3.1

The model-checking problem for ATL- $\Gamma$ can be solved in time $\mathcal{O}(m^{2}\cdot n\cdot l)$ for a self-organizing multi-agent system with $m$ states, a coalition of agents $|A|=n$ and a formula of length $l$ .

Proof

We adopt the proof strategy from [2]. We first construct the extended game structure $S^{F}$ , where the obedience/violation of local rules are encoded in the structure. To verify whether a temporal formula $\psi$ can be enforced by a coalition of agents $A$ through following its local rules in a self-organizing multi-agent system at state $q$ , we need to check formula $\mathcal{S},\Gamma,q\models\langle A\rangle\psi$ , which can be reduced to evaluating an ATL^∗ formula for $\mathcal{S}^{F}$ and $\langle\bot,q\rangle$ :

\mathcal{S}^{F},\langle\bot,q\rangle\models\llangle A\rrangle(\bigwedge_{a\in A}\Box followed_{a}\land\psi).

We then construct a 2-player turn-based synchronous game $\mathcal{S}^{F}_{A}$ , where player 1 controls all the actions of coalition $A$ (called A-move) leading to an auxiliary state, after which player 2 controls all the actions of coalition $\Sigma\backslash A$ (called B-move) leading to the next state of the original transition. Such a game can be interpreted as an AND-OR graph, for which we can solve certain invariance and reachability problems in linear time. Because following the local rules is a necessary condition for coalition $A$ to win the game, we can remove all the outgoing A-move in $\mathcal{S}^{F}$ from an state where $\lnot\bigwedge_{a\in A}followed_{a}$ holds and its outgoing transitions, which can be done in polynomial time to the number of states and the number of agents in $A$ . If the original game structure $\mathcal{S}$ has $m$ states, then the turn-based synchronous structure $\mathcal{S}^{F}_{A}$ has $\mathcal{O}(m^{2})$ states. We then perform normal model checking for $\llangle A\rrangle\psi$ in $\mathcal{S}^{F}_{A}$ , which can be done in polynomial time to the length of $\psi$ . Therefore, checking formula $\mathcal{S},\Gamma,q\models\langle A\rangle\psi$ is in the complexity of $\mathcal{O}(m^{2}\cdot n\cdot l)$ .

We then measure the complexity of verifying a self-organizing multi-agent system, namely checking whether a coalition of agents has full contribution to a temporal formula in a certain state. A coalition has full contribution to a temporal formula in a state if only if it is the minimal (w.r.t. set-inclusion) coalition that is both semantically independent with respect to that temporal formula and structurally independent from that state. To verify structural independence, we can encode agents’ communication in the structure like what we did for the obedience/violation of local rules. Namely, given a coalition $A$ , we define the extended game structure $\mathcal{S}^{E}=(k,Q,\pi^{E},\Pi^{E},ACT,d,\delta)$ as follows:

•

For each agent $a\in A$ , there is a new proposition $InA$ ; that is $\Pi^{E}=\Pi\cup\{InA_{a}\mid a\in A\}$ .
•

$\pi^{E}(q)=\pi(q)\cup\{InA_{a}\mid\tau_{a}(q)\subseteq A\}$ .

The new propositions $\{InA_{a}\mid a\in A\}$ allow us to identify the states where agents in $A$ only get input from agents inside the coalition. We then construct the extended game structure $\mathcal{S}^{EF}$ , where the obedience/violation of local rules are encoded in the structure. Therefore, evaluating whether a coalition of agents $A$ is an independent component with respect to $out(q,\Gamma_{A})$ can be again reduced to standard ATL formulas over states of $\mathcal{S}^{EF}$ .

Proposition 3.2

The model-checking problem for structural independence can be solved in time $\mathcal{O}(m^{2}\cdot n^{2})$ for a self-organizing multi-agent system with $m$ states and a coalition of agents $|A|=n$ .

Proof

Given a SOMAS $(\mathcal{S},\Gamma)$ , a state $q$ and a set of agents $A$ , $A$ is an independent component with respect to $out(q,\Gamma_{A})$ iff the state $\langle\bot,q\rangle$ of the extended game structure $\mathcal{S}^{EF}$ satisfies the following ATL^∗ formula:

\mathcal{S}^{EF},\langle\bot,q\rangle\models\llangle A\rrangle\bigwedge_{a\in A}\Box(followed_{a}\land InA_{a})

As we have to check $InA_{a}$ for each agent in $A$ , checking the above formula is in the complexity of $\mathcal{O}(m^{2}\cdot n^{2})$ .

With the results of Propositions 3.1 and 3.2, we can measure the complexity of verifying whether a coalition of agents has full contribution to a temporal formula in a certain state.

Proposition 3.3

The model-checking problem for verifying the full contribution of a coaltion of agents can be solved in time $\mathcal{O}(m^{2}\cdot n^{2}\cdot l\cdot 2^{n})$ for a self-organizing multi-agent system with $m$ states, a coalition of agents $|A|=n$ and a formula of length $l$ .

Proof

Given a SOMAS $(\mathcal{S},\Gamma)$ , a state $q$ , a set of agents $A(|A|=n)$ and a temporal formula $\psi$ with the length of $l$ , we need to follow Definition 2.6 to verify whether coalition $A$ has full contribution to $\psi$ in $q$ . Since we know that the model-checking problem for ATL- $\Gamma$ can be solved in time $\mathcal{O}(m^{2}\cdot n\cdot l)$ , and that the model-checking problem for structural independence can be solved in time $\mathcal{O}(m^{2}\cdot n^{2})$ , checking semantic and structural independence can be solved in time $\mathcal{O}(m^{2}\cdot n^{2}\cdot l)$ . Moreover, we need to ensure that $A$ is the minimal coalition that is both semantically independent and structurally independent. Hence, we have to check every subset of $A$ for its semantic independence and structural independence. Therefore, checking the full contribution of a coalition of agents in a state is in the complexity of $\mathcal{O}(m^{2}\cdot n^{2}\cdot l\cdot 2^{n})$ .

4 Decomposing a Self-organizing Multi-agent System: a Layered Approach

In Section 2 we explored the dependence relation between agents from both structural and semantic perspectives. However, we still have no idea how agents guided by their respective local rules bring about the global behavior of the system. If we check formula $\mathcal{S},\Gamma,q\models\langle\Sigma\rangle\psi$ and it returns true, it is just proved that all the agents in the system have full contribution to the global behavior of the system $\psi$ , which does not explain anything. For sure, we can enumerate all the possible coalitions of agents to check their contributions to the global behavior of the system, but it might be computationally expensive if the system has a large number of agents. Inspired by the decomposition approach in argumentation [21], we propose to decompose the system into different coalitions based on their dependence relation such that there is a partial order among different coalitions. Since a directed graph with nodes and arrows can better represent the dependence relation, we define a notion of a dependence graph w.r.t. a set of computations. Formally,

Definition 4.1 (Dependence Graph)

Given an SOMAS $(\mathcal{S},\Gamma)$ , a dependence graph w.r.t. a set of computations $out$ is a directed graph $G(V,E)$ where $V=\Sigma$ and $E=\{(a,b)\mid$ there exists $\lambda\in out$ and $q\in\lambda$ such that $a\in\tau_{b}(q)\}$ . Typically, given a state $q$ and a coalition of agents $A$ , when $G$ is a dependence graph w.r.t. a set of computations $out(q,\Gamma_{A})$ , we will denote it as $G(q,\Gamma_{A})$ .

In words, a dependence graph w.r.t. a set of computations consists of a set of nodes $V$ , which are the agents in $\mathcal{S}$ , and a set of arrows $E$ , each of which indicates one agent gets input from another agent in a state along a computation in $out$ . Having this graph allows us to analyze the dependence relation between agents and the dependence relation between coalitions of agents with respect to a set of computations.

Proposition 4.1

Given an SOMAS $(\mathcal{S},\Gamma)$ , a coalition $A$ is an independent component w.r.t. a set of computations $out$ iff $A$ does not get input from agents outside of $A$ in the corresponding dependence graph $G$ .

Proof

Coalition $A$ is an independent component w.r.t. a set of computations $out$ iff for all $\lambda\in out$ and $q\in\lambda$ $A$ is an independent component w.r.t. state $q$ iff for all $\lambda\in out$ and $q\in\lambda$ and $a\in A$ it is the case that $\tau_{a}(q)\subseteq A$ , which means that for all $\lambda\in out$ and $q\in\lambda$ and $a\in A$ it is the case that it is the case that $a$ does not get input from agents in $\Sigma\backslash A$ , iff any $a\in A$ does not get input from agents outside of $A$ in the corresponding dependence graph $G$ .

From that, we can check whether a coalition of agents is an independent component w.r.t. $out$ through simply checking its corresponding dependence graph.

Proposition 4.2

Given an SOMAS $(\mathcal{S},\Gamma)$ and two sets of computations $out$ , if a coalition of agents $A$ is an independent component w.r.t. a set of computations $out$ , then $A$ is also an independent component w.r.t. any set of computations $out^{\prime}$ where $out^{\prime}\subseteq out$ .

Proof

Let $G$ be the dependence graph of $out$ and $G^{\prime}$ be the dependence graph of $out^{\prime}$ . Because $out^{\prime}\subseteq out$ , $G^{\prime}$ is a spanning subgraph of $G$ . Therefore, if $A$ does not get input from other agents in $G$ , $A$ will also not get input from other agents in $G^{\prime}$ , which means that if $A$ is an independent component w.r.t. $out$ , then $A$ is also an independent component w.r.t. $out^{\prime}$ .

Typically, given an SOMAS $(\mathcal{S},\Gamma)$ , if a coalition of agents $A$ is an independent component w.r.t. $out(q,\Gamma_{A})$ , then $A$ is also an independent component w.r.t. $\lambda^{*}(q)$ ; if $A$ is not an independent component w.r.t. $\lambda^{*}(q)$ , then $A$ is also not an independent component w.r.t. $out(q,\Gamma_{A})$ . In this section, we will use a more complicated example illustrate our definitions.

Example 6

A multi-agent system consists of a couple of agents, each of which has specific capacity that is not common knowledge among agents. A complicated task is delegated to the agents and the agents have to cooperate to finish the task in a self-organizing way. The local rule for each agent is as follows: each agent works on one part of the task based on its capacity; once its part is finished, it passes the rest of the task to other agents who can continue via wireless signals until the whole task is finished. We will use our framework to study the contributions of agents and how they cooperate to finish the whole task. Given agents’ capacities, the whole task is finished along the computation $\lambda^{*}(q)$ . The dependence graph $G$ w.r.t. $\lambda^{*}(q)$ is represented as Figure.4(left), which consists of 5 agents $\{a,b,c,d,e\}$ and communication between them regarding the task information.

A dependence graph clearly illustrates not only the dependence relation between agents. When there exists circles in a dependence graph, we can shrink them down to single nodes based on the theory about strongly connected components and condensation graphs in graph theory. Because it is not the main concern of this paper, we omit the process of transforming a dependence graph to a condensation graph and assume that the dependence graph under consideration is a directed acyclic graph. As we mentioned before, we want to decompose the system such that there is a partial order of dependence among coalitions of agents. How to decompose the system based on the dependence graph becomes a problem we need to solve now. Similar to the solution in [21], we use a layering decomposition approach in this paper. We first propose the notion of layer. Formally,

Definition 4.2 (Layer of an Agent)

Given a dependence graph $G(V,E)$ w.r.t. a set of computations $out$ , for all $a\in V$ , the layer of $a$ is a function $\rho:V\to\mathbb{N}$ , and $\rho(a)$ is defined as:

•

if $a$ has no parent in $G$ , then $\rho(a)=0$ ;
•

otherwise, $\rho(a)=\max\{\rho(p)+1:p\text{ is a parent of }a\}$ ,

We use $h=\max\{\rho(a):a\in V\}$ to denote the highest layer.

The above definition indicates the layer of an agent in a given dependence graph in two cases. If $a$ is a leaf node in the dependence graph $G$ , then $a$ is located in the lowest layer such that it is independent on the behavior of any other agents. If $a$ is not a leaf node, then $a$ is located in the layer above all of its parents. A self-organizing multi-agent system can be decomposed into a number of layers. Formally,

Definition 4.3 (Decomposition of an SOMAS)

Given an SOMAS $(\mathcal{S},\Gamma)$ , a decomposition of $(\mathcal{S},\Gamma)$ w.r.t. a set of computations $out$ , denoted as $\operatorname{decomp}(\mathcal{S},\Gamma,out)$ , is a tuple

\operatorname{decomp}(\mathcal{S},\Gamma,out)=(L_{0},L_{1},\cdots,L_{h}),

where $L_{i}=\{a\in\Sigma\mid\rho(a)=i\}$ ( $0\leq i\leq h$ ).

Using this decomposition approach, any agents in the same layer are independent on each other, and any agents in a given layer are only dependent on the agents located in the lower layers. It is expressed by the following proposition:

Proposition 4.3

Given an SOMAS $(\mathcal{S},\Gamma)$ and a decomposition $\operatorname{decomp}(\mathcal{S},\Gamma,out)$ , for any $a\in L_{i},b\in L_{j}$ ( $0\leq i,j\leq h$ ):

•

if $i=j$ , then $a$ and $b$ do not get input from each other;
•

if $b$ gets input from $a$ , then $i<j$ .

Proof

If $i=j$ , agents $a$ and $b$ are on the same level. For $a$ located on $L_{i}$ , if $i=0$ , it has no parent, thus it does not get input from $b$ ; if $i>0$ , the parents of $a$ are located below $L_{i}$ , thus $b$ cannot reach $a$ , meaning that $a$ does not get input from $b$ . Similarly, $b$ does not get input from $a$ . If $b$ gets input from $a$ , then there exists an arrow coming from $a$ to $b$ . According to our decomposition approach, $a$ is located below $b$ . Hence, $i<j$ .

Thus, we organize the system in a way where there is a partial order of dependence among agents located in different layers. This layered structure helps us to find coalitions of agents which do not get input from other agents from the dependence graph efficiently. Starting from $L_{0}$ , any coalitions located in $L_{0}$ do not get input from other agents. We then go to $L_{1}$ , where each agent combining with its parents located in lower layers does not get input from other agents. After that, we go to a higher level until we reach $L_{h}$ . We have the following theorem to check whether a coalition of agents has full contribution to a temporal formula in a state.

Theorem 4.1

Given an SOMAS $(\mathcal{S},\Gamma)$ , a coalition of agents $A$ fully contributes to a temporal formula $\psi$ in a state $q$ iff $A$ satisfies the following conditions

•

$A$ does not get input from agents in $\Sigma\backslash A$ in the dependence graph $G(q,\Gamma_{A})$ ;
•

$\mathcal{S},\Gamma,q\models\langle A\rangle\psi$ ;
•

for any $A^{\prime}\subset A$ if it does not get input from agents in $\Sigma\backslash A^{\prime}$ in $G(q,\Gamma_{A^{\prime}})$ then $\mathcal{S},\Gamma,q\not\models\langle A^{\prime}\rangle\psi$ .

Proof

For the first condition, coalition $A$ does not get input from agents in $\Sigma\backslash A$ in the dependence graph $G(q,\Gamma_{A})$ if and only if coalition $A$ is an independent component w.r.t. $out(q,\Gamma_{A})$ , which means the coalition $A$ is structurally independent. The second condition ensures that $A$ is semantically independent w.r.t. $\psi$ . For the third condition, for any subsets of $A$ $A^{\prime}\subset A$ , if it gets input from agents in $\Sigma\backslash A^{\prime}$ in $G(q,\Gamma_{A^{\prime}})$ , it is not structurally independent; if it does not get input from agents in $\Sigma\backslash A^{\prime}$ in $G(q,\Gamma_{A^{\prime}})$ and $\mathcal{S},\Gamma,q\not\models\langle A^{\prime}\rangle\psi$ , it is structurally independent but not semantically independent. Thus, for any $A^{\prime}\subset A$ , it is either not structurally independent or not semantically independent, which means that $A$ is the minimal (w.r.t. set-inclusion) coalition that is both semantically independent with respect to $\psi$ and structurally independent from $q$ . Therefore, $A$ fully contributes to a temporal formula $\psi$ in a state $q$ .

It indicates how to verify whether a coalition of agents $A$ has full contribution to $\psi$ in state $q$ : structurally, we need to check whether $A$ does not get input from agents outside $A$ in the dependence graph of $out(q,\Gamma_{A})$ ; semantically, we need to check whether $A$ ensures $\psi$ by following local rules; for any of its proper subsets $A^{\prime}$ , if $A^{\prime}$ has been confirmed to be structurally independent w.r.t. $out(q,\Gamma_{A^{\prime}})$ , then we need to check whether it is not semantically independent w.r.t. $\psi$ . In other words, for any proper subsets of $A$ , we need to ensure it is either not structurally independent or not semantically independent w.r.t. $\psi$ from state $q$ .

Given a finite set of temporal formulas tformulas that we would like to verify, we need to follow a procedure to efficiently examine the contribution of agents to the global system behavior rather than checking an arbitrary coalition. The results from Proposition 4.3 and Theorem 4.1 can be used to design such a procedure. According to Proposition 4.2 if a coalition of agents $A$ is not an independent component w.r.t. $\lambda^{*}(q)$ then it is also not an independent component w.r.t. $out(q,\Gamma_{A})$ . Thus, we investigate the dependence graph $G$ of $\lambda^{*}(q)$ so that we can rule out the coalitions that are not independent components in $G$ . Given a computation $\lambda^{*}(q)$ and its corresponding dependence graph $G$ , we first find out all the coalitions of agents that do not get input from other agents according to the result of Proposition 4.3, putting them in the order of set inclusion. From the first coalition to the last coalition in the order, we follow Theorem 4.1 to check whether it has full contribution to any temporal property in tformulas. In this part, after we confirm that a coalition of agents $A$ is structurally and semantically independent w.r.t. a temporal formula $\psi$ , we check whether $A^{\prime}\subset A$ , which does not get input from other agents in $G(q,\Gamma_{A^{\prime}})$ , also bring about $\psi$ . If no, then $A$ is the minimal coalition (w.r.t. set-inclusion) coalition that is both semantically independent with respect to $\psi$ and structurally independent from $q$ . We provide the following pseudocode to illustrate the process.

Algorithm 1 Finding Agents’Full Contributions in an SOMAS

function FConSOMAS(

\mathcal{S},\Gamma,q,tformulas

)

def tformulas;

def hashmap = FindIndependentComponent(

\lambda^{*}(q)

);

for each

A

in hashmap do

A

is not an independent component w.r.t.

out(q,\Gamma_{A})

then

hashmap.remove(A);

end if

for each

\psi

in tformulas do

\mathcal{S},\Gamma,q\models\psi

then

for each

A^{\prime}\subset A

if hashmap.get(

A^{\prime}

)!= null &

\mathcal{S},\Gamma,q\not\models\psi

then

hashmap.put(

A

\psi

);

end if

end for

end if

end for

return hashmap;

end function

When it is finished, we collect the information about agents’ full contributions in a set, which allows us to understand how different coalitions of agents contribute to the global system behavior.

Definition 4.4 (Agents’ Independence in Terms of Full Contributions)

Given an SOMAS $(\mathcal{S},\Gamma)$ and a state $q$ , agents’ independence in terms of their full contributions in $(\mathcal{S},\Gamma)$ is a set $F(q)$ containing the information of agents’ full contributions, namely $F(q)=\{(A,\psi_{A})\mid$ Coalition $A$ has full contribution to $\psi_{A}$ in state $q$ . $\}$ .

Example 7

A decomposition of dependence graph $G$ in Fig.4(right) is as follows. According to Definition 4.2, $\rho(a)=0$ , $\rho(b)=1$ , $\rho(c)=2$ , $\rho(d)=1$ and $\rho(e)=0$ . Therefore, the system is decomposed into three layers: $\operatorname{decomp}(\mathcal{S},\Gamma)=(L_{0},L_{1},L_{2})$ , where $L_{0}=\{a,e\}$ , $L_{1}=\{b,d\}$ and $L_{2}=\{c\}$ . Based on the decomposition, from $L_{0}$ to $L_{2}$ , we can find multiple independent components, namely $\{a\}$ , $\{e\}$ , $\{a,e\}$ , $\{a,b,e\}$ , $\{d,e\}$ , $\{a,d,e\}$ , $\{a,b,d,e\}$ and $\Sigma$ . We then examine whether they fully contribute to any temporal formula one by one, which does a lot of savings over checking $2^{5}$ possible coalitions without using the dependence graph. Starting from $\{a\}$ , we check whether agent $a$ also does not get input from other agents in the dependence graph $G(q,\Gamma_{\{a\}})$ , and check whether it ensures $\psi_{a}$ by following its local rule. If both return yes, then $a$ fully contributes to $\psi_{a}$ . We perform the same examination for coalition $\{e\}$ . For coalition $\{a,e\}$ , after confirming that it is both semantically independent with respect to $\psi$ and structurally independent from $q$ , we still need to check whether neither coalitions $\{a\}$ nor $\{e\}$ brings about $\psi_{ae}$ to ensure the minimization requirement. The verification is finished when we have done with $\Sigma$ . Suppose we have the following result: $F(q)=\{(\{a\},\psi_{a}),(\{d,e\},\psi_{de}),(\{a,b,e\},\psi_{abe}),(\Sigma,\psi)\}$ , each of which indicates that a coalition has full contribution to a part of the task. Therefore, $F(q)$ contains the information on how different coalitions of agents finish the whole task.

5 Modeling Constraint Satisfaction Problems

In mult-agent systems, it is normal that agents have personal goals and constraints. From the perspective of the system, we would like to find a solution such that we can balance the satisfaction of the goals and constraints among agents. In mathematics, those problems are called constraint satisfaction problems. Constraint satisfaction problems are NP-complete in general, which means that it will more and more computationally expensive to solve those problems in centralized way when we enlarge the size of the problem. After realizing that, people start to look at agents themselves and the cooperation among them: agents can negotiate as to reach a global equilibrium. Algorithms based on self organization have been developed to solve various constraint satisfaction problems, such as task/resource allocation [22] and relation adaption [31]. Formally, a constraint satisfaction problem is defined as a triple $(X,D,C)$ , where

•

$X=\{x_{1},\ldots,x_{n}\}$ is a set of variables;
•

$D=\{D_{1},\ldots,D_{n}\}$ is a set of domains;
•

$C=\{C_{1},\ldots,C_{m}\}$ is a set of constraints.

Each variable $x_{i}$ can take on the values in its nonempty domain $D_{i}$ . Every constraint $C_{j}\in C$ is a pair $(t_{j},R_{j})$ , where $t_{j}\subset X$ is a subset of n variables and $R_{j}$ is the relation on $t_{j}$ . An evaluation of the variables is a function $v$ from a subset of variables to a particular set of values in the corresponding subset of domains. An evaluation $v$ is said to satisfy a constraint $(t_{j},R_{j})$ if the values assigned to the variables $t_{j}$ satisfies the relation $R_{j}$ . A solution to the constraint satisfaction problem is an evaluation that include all the variables and do not violate any of the constraints.

Using our framework of self-organizing multi-agent systems to model a constraint satisfaction problem, we can see a complete evaluation that includes all the variables as a particular state in the system, and a self-organization based algorithm is a set of local rules we design for agents to follow. The goal of the system is to converge to a stable state where the values of $X$ do not violate any constraints, which is a feasible solution to the problem. Notice that set $C$ consists of multiple constraints. An evaluation that satisfies constraints $C^{\prime}$ always implies an evaluation that satisfies constraints $C^{\prime\prime}$ if $C^{\prime\prime}\subseteq C^{\prime}$ . Next, we will use a real example to illustrate how we use our framework to model a constraint satisfaction problem.

Multi-agent systems can be used to support information exchange within user communities where each user agent represents a user’s interests. But how does a user agent make contact with other user agents with common interests? We can use a peer-to-peer network, but this could flood the network with queries, risking overloading the system. A decentralized solution based on middle agents can self-organize to form communities among agents with common interests [28]. User agents represent users and each user agent registers with one or more middle agent. User agents (requestors) send queries about their user’s interests to middle agents. Given these queries, each middle agent then search among the information it holds from other user agents registered with it. If it can respond to a query based on this information then the search is completed. Otherwise, the middle agent communicates with other middle agents in order to try and obtain the information. Once this has been done, the middle agent relays results of the search to the requester. After that, the middle agent checks whether both the requester and the provider are within its group. If not, the middle agent of the requester transfers the provider to its group, so that both user agents are in the same group. The consequence is that users with common interests form a community. The querying behavior of user agents builds up a profile of their interests, which is updated by successive queries. It is a solution with self-organization features that solves a constraint satisfaction problem that the middle agents where user agents register correspond to the set of variables $X$ , the possible middle agents where user agents can register correspond to the domains of the variables $D$ , and user agents’ interests in other user agents correspond to the constraints $C$ . Compared to centralizedly solving the problem that might encounter computational issues when the number of users increases, the above solution is a highly scalable process that operates efficiently with a large number of users. As user agents broadcast their queries in the system when implementing the solution, it is not required that the system designer is aware of user agents’ interests beforehand.

We now use our framework to model the example. The system has a set of user agents $U$ and a set of middle agents $M$ ; each middle agent can register $reg$ , disregister $disreg$ a user agent or does nothing. Function $int:U\to\mathcal{P}(U)$ returns the static interest of each user agent $u\in U$ . Each state $q$ is labeled with propositions, each of which is of the form $reg(u,m)$ , meaning that user agent $u$ registers in middle agent $m$ . We assume that middle agents are aware of the positions where user agents register, but not the interests of user agents before user agents broadcast their queries in the system. The system moves from one state to another state once a user agent registers or disregister with a user agent. The goal of the system is to converge to a state $q^{*}$ where all user agents are in their own user communities. As Fig. 5 described, a user community consists of user agent(s) and middle agent(s); for any user agent in the community, it registers with the same middle agent as its interested user agents do. In order to formalize this property, we extend our semantics as follows: given $U^{\prime}\subseteq U$ and $M^{\prime}\subseteq M$ ,

•

$\mathcal{S},\Gamma,q\models\operatorname{com}(U^{\prime},M^{\prime})$ iff for all $u\in U^{\prime}$ and $u^{\prime}\in int(u)$ there exists $m\in M^{\prime}$ such that $\mathcal{S},\Gamma,q\models reg(u,m)\land reg(u^{\prime},m)$ .

Local rule $\langle\tau,\gamma\rangle$ for each agent is prescribed as follows: if a user agent $u_{1}$ has interest in another user agent $u_{2}$ while they don’t register with the same middle agent, then the middle agent of $u_{2}$ has to disregister $u_{2}$ and send the information about $u_{2}$ to the middle agent of $u_{1}$ so that it can register $u_{2}$ . Suppose at the starting state $q_{0}$ user agents randomly register with different middle agents and each has interest in some other user agents (see Table 1). Starting from $q_{0}$ , $u_{1}$ asks a question about $u_{2}$ . After hearing the query about $u_{2}$ , $m_{2}$ disregisters $u_{2}$ and sends information about $u_{2}$ to $m_{1}$ , which moves the system from state $q_{0}$ to state $q_{1}$ . After getting the information about $u_{2}$ from $m_{2}$ , $m_{1}$ registers $u_{2}$ , which moves the system from state $q_{1}$ to state $q_{2}$ . In state $q_{2}$ , both $u_{1}$ and $u_{2}$ register with the same middle agent $m_{1}$ . Later on, $u_{2}$ asks a question about $u_{1}$ . Because $u_{1}$ and $u_{2}$ register with the same middle agent $m_{1}$ , the system does not change anything from the query. And then $u_{3}$ asks a question about $u_{4}$ . Similar to $u_{2}$ , $m_{1}$ disregisters $u_{4}$ after hearing the query, and $m_{3}$ registers $u_{4}$ after getting the information about $u_{4}$ from $m_{1}$ . And then $u_{4}$ asks a question about $u_{3}$ , which does not trigger any changes to the system. Based on the local rules, the dependence graph between user agents and middle agents in terms of their communication along the computation $\lambda^{*}(q_{0})$ is shown in Fig. 6. Triggered by the queries, all agents follow their local rules to behave and the system transits from $q_{0}$ to $q_{4}$ . See Fig. 7 for the state transitions of the system and the valuation of each state. Because in $q_{4}$ both $u_{1}$ and $u_{2}$ with common interests register with $m_{1}$ and both $u_{3}$ and $u_{4}$ with common interests register with $m_{3}$ , $q_{2}$ satisfies the property of our desired state. Starting from a disorder state $q_{0}$ , the system finally converges to state $q_{4}$ where for each user $u\in U$ it registers with the same middle agent as its interested user agents do, forming two user communities $\operatorname{com}(\{u_{1},u_{2}\},\{m_{1}\})$ and $\operatorname{com}(\{u_{3},u_{4}\},\{m_{3}\})$ . How does the system reach this desired state? What are the agents’ contributions to forming such two communities? Here is the analysis.

Table 1: User agents’ interests and their initial registration positions

User Agent	Interest	Register in
$u_{1}$	$u_{2}$	$m_{1}$
$u_{2}$	$u_{1}$	$m_{2}$
$u_{3}$	$u_{4}$	$m_{3}$
$u_{4}$	$u_{3}$	$m_{1}$

From Fig. 6, we can decompose the system into four layers, which are all the user agens as layer 0, $\{m_{2}\}$ as layer 1, $\{m_{1}\}$ as layer 2 and $\{m_{3}\}$ as layer 3. We can see there are lots of independent components w.r.t. computation $\lambda^{*}(q_{0})$ . Because the contributions of user agents are not encoded in the system, we do not discuss the independent components that are formed only by user agents. Given a set of temporal formulas $\{\Diamond\operatorname{com}(\{u_{1},u_{2}\},\{m_{1}\}),\Diamond\operatorname{com}(\{u_{3},u_{4}\},\{m_{3}\})\}$ , we verify which coalition of agents full contributes to any of them. Firstly, coalition $\{u_{1},u_{2},m_{1},m_{2}\}$ has full contribution to $\Diamond\operatorname{com}(\{u_{1},u_{2}\},\{m_{1}\})$ . This is because any agents in the coalition do not get input from agents outside the coalition, and they form the community of $\{u_{1},u_{2},m_{1}\}$ , which can be expressed by

\mathcal{S},\Gamma,q_{0}\models\langle u_{1},u_{2},m_{1},m_{2}\rangle\Diamond\operatorname{com}(\{u_{1},u_{2}\},\{m_{1}\}),

and apparently it cannot be achieved without any of them, which satisfies the minimization condition. Secondly, consider community $\operatorname{com}(\{u_{3},u_{4}\},\{m_{3}\})$ . From Fig. 6, we can see that coalition $\{u_{3},u_{4},m_{3}\}$ is not an independent component as it gets input from middle agent $m_{1}$ . Finally, the whole system fully contributes to forming the two communities $\operatorname{com}(\{u_{1},u_{2}\},\{m_{1}\})$ and $\operatorname{com}(\{u_{3},u_{4}\},\{m_{3}\})\}$ .

Such information regarding agents’ full contributions allows us to understand how user agents’ interest are satisfied and how user communities are formed, which facilitates the development of the system. For example, since coalition $\{u_{1},u_{2},m_{1},m_{2}\}$ has full contribution to $\Diamond\operatorname{com}(\{u_{1},u_{2}\},\{m_{1}\})$ , the community will not change even if we change the interests of $u_{3}$ and $u_{4}$ or $m_{3}$ does not register $u_{4}$ .

6 Related Work

In order to understand the complex link between local agent behavior and system level behavior, we need to study the independence between local agent behavior in terms of ensuring properties. Coalition-related logic achieves that from different perspectives. For instance, alternating temporal logic (ATL) and game theory can be used to check whether a coalition of agents can enforce a state property regardless of what other agents do [19]. [1] study whether a normative system remains effective even though some agents do not comply with it. [30] identifies two types of system properties that are unchangeable by restricting the joint behavior of a coalition. Apart from the semantics dimension, we have proposed the notion of independent components, a coalition of agents which only get input information from agents in the coalition. It is a structural dimension to represent a coalition of agents whose behavior is independent on the behavior of agents outside of the coalition.

If we see local rules as norms that are used to regulate the behavior of the systems, self-organizing multi-agent systems are actually a category of normative multi-agent systems. In preventative control systems [26], norms are represented as hard constraints where violations are impossible, but this does not respect agents’ autonomy. Soft constraints are used in detective control systems where norms are possible to be violated but agents are motivated to follow the norms through sanctions or punishments [5]. It is indeed more flexible than setting hard constraints in the system. However, agents coming from an open environment have their own personal situations such as knowledge and preferences, which might not be known to the designer of the system. In such a case, the system designer cannot identity which outcome is desired thus it is hard to identify legal computations to get there [7][20]. The norms that we consider in this paper are designed based on agents’ communication. As the norm prescribes, agents are supposed to communicate with each other about their own situations and what agents need to do depends on the communication results. Such type of norms are in fact widely used in multi-agent systems because it allows agents to regulate the system by themselves [28][27][22].

The logic we use in this paper is inspired by ATL [2]. ATL is usually used to reason about the strategies of participating agents [6][15]: formula $\llangle A\rrangle\psi$ is read as coalition $A$ have a strategy or can collaborate to bring about formula $\psi$ , which can be seen as the capacity of the participating agents to ensure a result no matter what other agents outside of the coalition do. A strategy is a function that takes a state (imperfect recall) or a sequence of states (perfect recall) as an argument and outputs an action, which can be seen as a plan. In order to make a plan for a coalition of agents to ensure a property, there is an external that is aware of the available actions from each agent and the game structure. In [Alur et al., 2002], the authors use a game between a protagonist and an antagonist to gain more intuition about ATL formulas. The ATL formula $\llangle A\rrangle\psi$ is satisfied at state $q$ iff the protagonist has a winning strategy to achieve $\psi$ in this game, which means that the protagonist is aware of the available actions from each agent and the game so that he can make a strategy (or a plan) for coalition $A$ to win the game. However, in a self-organizing multi-agent system, agents only have local view of the system, which is in this paper the state where they are, their own internal functions and the actions that are available to them and the local rules they need to follow, but not the internal functions of other agents and the actions that are available to other agents. Hence, there is no external to centrally make a plan for agents to follow. The logic in this paper is used to reason about the local rules of the participating agents: formula $\langle A\rangle\psi$ is read as coalition $A$ bring about formula $\psi$ by following their local rules no matter what other agents outside the coalition do. The use of logic and graph theory is new in the research of multi-agent systems, but it has appeared in the area of argumentation. An abstract argumentation framework can be represented as a directed graph (called a defeat graph) where nodes represent arguments and arcs represent attacks between them [14]. [21] use strongly connected components in graph theory to decompose an abstract argumentation framework for efficient computation of argumentation extensions. The decomposition approach in this paper is inspired by that, while we use it not for efficient computation but for system verification.

While we use modal logic to understand the complex link between local agent behavior and system level behavior, one could think that causal reasoning is a plausible alternative. Causal reasoning is the process of identifying the relationship between a cause and its effect [23]. It indeed has been used to identify the causal relation between macro- and micro-variables in [9] [8]. For self-organizing multi-agent systems, the local rules that agents follow are the cause and the global property they contribute is the effect. But sometimes it might be difficult to identify the causal relation because of the interactions between agents. In such cases, causal reasoning can still be combined with our graph-based layered approach to decompose the system, which is similar to the idea proposed by Judea Pearl and Thomas Verma to combine logic and directed graphs for causal reasoning [24].

7 Conclusion

Self-organization has been introduced to multi-agent systems as an internal control process or mechanism to solve difficult problems spontaneously. However, because a self-organizing multi-agent system has autonomous agents and local interactions between them, it is difficult to predict the global behavior of the system from the behavior of the agents we design deductively, making implementation the usual way to evaluate a self-organizing multi-agent system. Therefore, we believe that if we can understand how agents bring about the behavior of the system in the sense that which coalition contributes to which system property independently, the development of self-organizing multi-agent systems will be facilitated. In this paper, we propose a logic-based framework for self-organizing multi-agent systems, where abstract local rules are defined in the way that agents make their next moves based on their communication with other agents. Such a framework allows us to verify properties of the system without doing implementation. A structural property called independent components is introduced to represent a coalition of agents which do not get input from agents outside the coalition. The dependence relation between coalitions of agents regarding their contributions to the global behavior of the system is reasoned about from the structural and semantic perspectives. We then show model-checking a formula in our language remains close to the complexity of model-checking standard ATL, while model-checking whether a coalition of agents has full contribution to a temporal property is in exponential time. Moreover, we combine our framework with graph theory to decompose a system into different coalitions located in different layers. The resulting information about agents’ full contributions allows us to understand the complex link between local agent behavior and system level behavior in a self-organizing multi-agent system. We finally show how we can use our framework to model a constraint satisfaction problem, where a solution based on self-organization is used. Certainly, there may be some possible limitations in this study: for example, we only consider communication as the interaction between agents, which does not capture all types of interaction in the system. Moreover, the dependence graph with respect to computation $\lambda^{*}(q)$ is determined by agents’ communication required by local rules. Thus, the internal function $m_{i}$ of each agent play an important role in the global system behavior. In the future, it will be interesting to investigate the robustness of self-organizing multi-agent systems due to the change of internal functions, which is possible to happen when the system is deployed in an open environment and thus agents can join or exit the system as they want.

References

[1] Thomas Ågotnes, Wiebe Van der Hoek, and Michael Wooldridge, ‘Robust normative systems and a logic of norm compliance’, Logic Journal of IGPL, 18(1), 4–30, (2010).
[2] Rajeev Alur, Thomas A Henzinger, and Orna Kupferman, ‘Alternating-time temporal logic’, Journal of the ACM (JACM), 49(5), 672–713, (2002).
[3] Carole Bernon, Valérie Camps, Marie-Pierre Gleizes, and Gauthier Picard, ‘Tools for self-organizing applications engineering’, in International Workshop on Engineering Self-Organising Applications, pp. 283–298. Springer, (2003).
[4] Carole Bernon, Marie-Pierre Gleizes, Sylvain Peyruqueou, and Gauthier Picard, ‘Adelfe: a methodology for adaptive multi-agent systems engineering’, in International Workshop on Engineering Societies in the Agents World, pp. 156–169. Springer, (2002).
[5] Ronen I Brafman and Moshe Tennenholtz, ‘On partially controlled multi-agent systems’, Journal of Artificial Intelligence Research, 4, 477–507, (1996).
[6] Nils Bulling, Modelling and Verifying Abilities of Rational Agents, Papierflieger-Verlag, 2010.
[7] Nils Bulling and Mehdi Dastani, ‘Norm-based mechanism design’, Artificial Intelligence, 239, 97–142, (2016).
[8] Krzysztof Chalupka, Automated Macro-scale Causal Hypothesis Formation Based on Micro-scale Observation, Ph.D. dissertation, California Institute of Technology, 2017.
[9] Krzysztof Chalupka, Tobias Bischoff, Pietro Perona, and Frederick Eberhardt, ‘Unsupervised discovery of el nino using causal feature learning on microlevel climate data’, in Proceedings of the Thirty-Second Conference on Uncertainty in Artificial Intelligence, pp. 72–81, (2016).
[10] Edmund M. Clarke, E Allen Emerson, and A Prasad Sistla, ‘Automatic verification of finite-state concurrent systems using temporal logic specifications’, ACM Transactions on Programming Languages and Systems (TOPLAS), 8(2), 244–263, (1986).
[11] Edmund M Clarke Jr, Orna Grumberg, Daniel Kroening, Doron Peled, and Helmut Veith, Model checking, MIT press, 2018.
[12] Giovanna Di Marzo Serugendo, Marie-Pierre Gleizes, and Anthony Karageorgos, ‘Self-organization in multi-agent systems’, Knowledge Engineering Review, 20(2), 165–189, (2005).
[13] Marco Dorigo, Mauro Birattari, and Thomas Stutzle, ‘Ant colony optimization’, IEEE computational intelligence magazine, 1(4), 28–39, (2006).
[14] Phan Minh Dung, ‘On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games’, Artificial intelligence, 77(2), 321–357, (1995).
[15] Valentin Goranko, Antti Kuusisto, and Raine Rönnholm, ‘Game-theoretic semantics for alternating-time temporal logic’, ACM Transactions on Computational Logic (TOCL), 19(3), 1–38, (2018).
[16] VI Gorodetskii, ‘Self-organization and multiagent systems: I. models of multiagent self-organization’, Journal of Computer and Systems Sciences International, 51(2), 256–281, (2012).
[17] VI Gorodetskii, ‘Self-organization and multiagent systems: Ii. applications and the development technology’, Journal of Computer and Systems Sciences International, 51(3), 391–409, (2012).
[18] Abdelkader Khelil and Rachid Beghdad, ‘Esa: an efficient self-deployment algorithm for coverage in wireless sensor networks’, Procedia Computer Science, 98, 40–47, (2016).
[19] Max Knobbout and Mehdi Dastani, ‘Reasoning under compliance assumptions in normative multiagent systems’, in Proceedings of the 11th International Conference on Autonomous Agents and Multiagent Systems-Volume 1, pp. 331–340. International Foundation for Autonomous Agents and Multiagent Systems, (2012).
[20] Max Knobbout, Mehdi Dastani, and John-Jules Ch Meyer, ‘Formal frameworks for verifying normative multi-agent systems’, in Theory and Practice of Formal Methods, 294–308, Springer, (2016).
[21] B. Liao, Efficient Computation of Argumentation Semantics, Intelligent systems series, Elsevier Science, 2013.
[22] Kathryn Sarah Macarthur, Ruben Stranders, Sarvapali Ramchurn, and Nicholas Jennings, ‘A distributed anytime algorithm for dynamic task allocation in multi-agent systems’, in Twenty-Fifth AAAI Conference on Artificial Intelligence, (2011).
[23] Judea Pearl, Causality, Cambridge university press, 2009.
[24] Judea Pearl and Thomas Verma, The logic of representing dependencies by directed graphs, University of California (Los Angeles). Computer Science Department, 1987.
[25] Gauthier Picard, Carole Bernon, and Marie-Pierre Gleizes, ‘Etto: emergent timetabling by cooperative self-organization’, in International Workshop on Engineering Self-Organising Applications, pp. 31–45. Springer, (2005).
[26] Yoav Shoham, ‘Agent-oriented programming’, Artificial intelligence, 60(1), 51–92, (1993).
[27] Gabriele Valentini, Heiko Hamann, and Marco Dorigo, ‘Self-organized collective decision making: The weighted voter model’, in Proceedings of the 2014 international conference on Autonomous agents and multi-agent systems, pp. 45–52. International Foundation for Autonomous Agents and Multiagent Systems, (2014).
[28] Fang Wang, ‘Self-organising communities formed by middle agents’, in Proceedings of the first international joint conference on Autonomous agents and multiagent systems: part 3, pp. 1333–1339. ACM, (2002).
[29] Michael Wooldridge and Wiebe Van Der Hoek, ‘On obligations and normative ability: Towards a logical analysis of the social contract’, Journal of Applied Logic, 3(3-4), 396–420, (2005).
[30] Jun Wu, Chongjun Wang, and Junyuan Xie, ‘A framework for coalitional normative systems’, in The 10th International Conference on Autonomous Agents and Multiagent Systems-Volume 1, pp. 259–266, (2011).
[31] Dayong Ye, Minjie Zhang, and Danny Sutanto, ‘Self-organization in an agent network: A mechanism and a potential application’, Decision Support Systems, 53(3), 406–417, (2012).
[32] Dayong Ye, Minjie Zhang, and Athanasios V Vasilakos, ‘A survey of self-organization mechanisms in multiagent systems’, IEEE Transactions on Systems, Man, and Cybernetics: Systems, 47(3), 441–461, (2016).