Learning-based Formal Synthesis of Cooperative Multi-agent Systems

TL;DR

This paper introduces a formal, learning-based framework for synthesizing coordination policies in multi-agent systems, ensuring global mission satisfaction through local task decomposition, supervisor synthesis, and motion planning, validated by multi-robot experiments.

Contribution

It presents a novel divide-and-conquer formal synthesis approach using modified L* algorithms for multi-agent coordination with verified global specifications.

Findings

Effective multi-robot coordination demonstrated

Automated supervisor synthesis verified in experiments

Framework guarantees global mission satisfaction

Abstract

We propose a formal design framework for synthesizing coordination and control policies for cooperative multi-agent systems to accomplish a global mission. The global performance requirements are specified as regular languages while dynamics of each agent as well as the shared environment are characterized by finite automata, upon on which a formal design approach is carried out via divide-and-conquer. Specifically, the global mission is decomposed into local tasks; and local mission supervisors are designed to accomplish these local tasks while maintaining the multi-agent performance by integrating supervisor synthesis with compositional verification techniques; finally, motion plans are automatically synthesized based on the obtained mission plans. We present three modifications of the L* learning algorithm such that they are adapted for the synthesis of the local mission supervisors, the compositional verification and the synthesis of local motion plans, to guarantee that the collective behavior of the agents will ensure the satisfaction of the global specification. Furthermore, the effectiveness of the proposed framework is demonstrated by a detailed experimental study based on the implementation of a multi-robot coordination scenario. The proposed hardware-software architecture, with each robot's communication and localization capabilities, is exploited to examine the automatic supervisor synthesis with inter-robot communication.

Figures

Tables

Table 1. TABLE I: Mission Events of the Robots.

Event	Explanation
$h_i$	Robot $G_i\left(i=1,2,3\right)$ receives the mission request.
$F$	Robot $G_2$ extinguishes the fire.
$G_{i}in{R}_j$	Robot $G_i$ stays at Room $R_j(i,j=1,2,3)$.
$Open$	Open $D_1$.
$Close$	Close $D_1$.
$D_{1}open$	The status that $D_1$ is opened by robots.
$D_{1}close$	The status that $D_1$ is closed by $G_1$ and $G_3$.
$r$	All the robots assemble in Room 1.

Equations

$$G=(Q,\Sigma ,q_0,\delta ,Q_m),$$

$$\forall \tilde{q}\in \tilde{Q},\sigma \in \Sigma ,\tilde{\delta }(\tilde{q},\sigma )=\{\begin{array}{ll}\delta (\tilde{q},\sigma ),& \text{mbox}if\tilde{q}\in Q\wedge \delta (\tilde{q},\sigma )!,\\ q_e,& \text{mbox}if\tilde{q}=q_e\vee \delta (\tilde{q},\sigma )=\varnothing .\end{array}$$

$$\begin{array}{rl}& \forall q=(q_1,q_2)\in Q,\sigma \in \Sigma ,\\ & \delta (q,\sigma )=\{\begin{array}{ll}({\delta }_1(q_1,\sigma ),{\delta }_2(q_2,\sigma )),& \text{mbox}if{\delta }_1(q_1,\sigma )!,{\delta }_2(q_2,\sigma )!,\\ ({\delta }_1(q_1,\sigma ),q_2),& \text{mbox}if{\delta }_1(q_1,\sigma )!,\sigma \notin {\Sigma }_2,\\ (q_1,{\delta }_2(q_2,\sigma )),& \text{mbox}if{\delta }_2(q_2,\sigma )!,\sigma \notin {\Sigma }_1,\\ \varnothing ,& \text{mbox}otherwise,\end{array}\end{array}$$

$$|{|}_{i\in I}{L}_i=\bigcap _{i\in I}{P}_i^{-1}(L_i).$$

$$G_i=(Q_i,{\Sigma }_i,q_{i,0},{\delta }_i,Q_{i,m}).$$

$${\mathcal{E}}_0=(V,{⟶}_{{\mathcal{E}}_0},D,F_D),$$

$$G_i^m=(V,D,v_{i,0},{\delta }_i^m,V_m),$$

$$\forall v\in V,d\in D:{\delta }_i^m(v,d)=v^{\prime }\iff d\in F_D(v,v^{\prime }),$$

$${\pi }_i:{\Sigma }_i\to V,$$

$$\begin{array}{r}{L}_i=P_i(L)\subseteq P_i(L(G))=P_i\left[\bigcap _{i\in I}{P}_i^{-1}[P_i(L(G))]\right]\\ \subseteq P_i(P_i^{-1}[P_i(L(G))])=P_i(L(G))=L(G_i),\end{array}$$

$$T_i^1(t)=\{\begin{array}{ll}0,& \text{mbox}ift\notin L_i,\\ 1,& \text{mbox}otherwise.\end{array}$$

$$T_i^j(t)=\{\begin{array}{ll}0,& \text{mbox}if{T}_i^{j-1}(t)=0\text{mbox}ort\in D_{ui}(C_i^j){\Sigma }_i^{\ast },\\ 1,& \text{mbox}otherwise,\end{array}$$

$$\begin{array}{rl}{K}_1& :=L_i,\\ K_j& :=K_{j-1}-D_{ui}(C_i^j){\Sigma }_i^{\ast }.\end{array}$$

$$t\in L(M_j)\Delta K_j.$$

$$\begin{array}{rl}{K}_1& :=L_i,\\ K_{j+1}& :=K_j-[(L(G_i)-K_j)/{\Sigma }_{i,uc}]{\Sigma }_i^{\ast }.\end{array}$$

$$\sup C_i(L_i)=L_i-[(L(G_i)-L_i)/{\Sigma }_{i,uc}^{\ast }]{\Sigma }_i^{\ast }.$$

$$L_i-D_{ui}(C_i^j){\Sigma }_i^{\ast }=L_i-[D_{ui}(L(G_i)-K_i)]{\Sigma }_i^{\ast },$$

$$M_i:=S_i||G_i(i\in I).$$

$$T_i(t)=\{\begin{array}{ll}1,& \text{mbox}if⟨\mathcal{D}\mathcal{F}\mathcal{A}(t)⟩M_i⟨L⟩\text{mbox}istrue,\\ 0,& \text{mbox}otherwise.\end{array}$$

$$L_i^{temp}=L_i^{mi}-P_i(t);$$

$$L_i=L_i^{temp}-co{L}_i^{temp}{\Sigma }_i^{\ast },$$

$$P_i(L){\Sigma }_{i,uc}\cap L(G_i)\subseteq P_i(L),$$

$$P_i^{-1}\left[P_i(L){\Sigma }_{i,uc}\cap L(G_i)\right]\subseteq P_i^{-1}(P_i(L)).$$

$$P_i^{-1}\left[P_i(L){\Sigma }_{i,uc}\cap L(G_i)\right]=P_i^{-1}\left[P_i(L){\Sigma }_{i,uc}\right]\cap P_i^{-1}(L(G_i)),$$

$$\begin{array}{rl}L{\Sigma }_{i,uc}\cap L(G)& \subseteq P_i^{-1}(P_i(L)){\Sigma }_{i,uc}\cap P_i^{-1}(P_i(L(G)))\\ & \subseteq P_i^{-1}\left[P_i(L){\Sigma }_{i,uc}\right]\cap P_i^{-1}(L(G_i))\\ & =P_i^{-1}\left[P_i(L){\Sigma }_{i,uc}\cap L(G_i)\right]\subseteq P_i^{-1}(P_i(L)).\end{array}$$

$$\bigcap _{i\in I}\left[L{\Sigma }_{i,uc}\cap L(G)\right]\subseteq \bigcap _{i\in I}{P}_i^{-1}(P_i(L))=|{|}_{i\in I}{P}_i(L),$$

$$L{\Sigma }_{uc}\cap L(G)\subseteq |{|}_{i\in I}{P}_i(L)=L,$$

$$S(L)=\{H\subseteq L|(L=\overline{L})\wedge (H=|{|}_{i\in I}{P}_i(H))\}$$

$$L_i=\overline{L_i}\subseteq L_i^{temp}.$$

$${\tilde{L}}_i^{mi}=\sup C_i(L_i)\subseteq L_i\subseteq L_i^{temp}\subseteq L_i^{mi}$$

Full text

I Introduction

Cooperative multi-agent systems that consist of a number of agents collaborating through distributed physical interaction and wireless communication to fulfill certain performance objectives have emerged as a hot research topic in the past two decades, due to their wide applications in both academia and industry, ranging from power grids, transportation systems, computer networks to robotic teams. Numerous distributed coordination and control problems have been extensively studied, see, e.g., [1, 2, 5, 3, 4, 6] and the references therein.

One of the essential problems in cooperative multi-agent systems is how to design control policies for each agent and coordination strategies among them such that certain desirable global specifications can be fulfilled. We are therefore motivated to derive a formal synthesis framework to assure the accomplishment of high-level missions for a team of cooperative agents. In particular, we consider multiple intelligent agents that can move around in a partitioned and uncertain environment while satisfying a team mission specified by a regular language [7]. We assume that the mission and motion capabilities of each agent can be respectively modeled as two finite automata [8]. A learning-based formal synthesis approach is performed to coordinate the cooperative multi-agent systems as follows. First, the global mission is properly decomposed into local missions that can be executed by the corresponding agents. Towards this end, we present a learning-based algorithm for synthesizing local mission supervisors to fulfill local missions. Secondly, after deducing the local tasks, a learning-based algorithm is provided to compositionally justify whether or not the collective behavior of all agents satisfies the global mission [9]. Finally, a motion plan [10] corresponding to the local mission is generated based on a nominal environment model. In case the motion plans fail to be feasible due to the uncertainties of the real environment, motion replanning is triggered and the global mission will be achieved iteratively. The contributions of our work can be summarized as:

1) Compared to [1, 10], we account for the controllability of the mission events and derive local supervisors that restrict the behavior of each agent properly. Furthermore, we modify the $L^{*}$ learning algorithm [11] and apply the modified algorithm to the synthesis of the local supervisors to actively learn a manageable local task even if the agent’s model is not known a priori, rendering our approach the capability of handling system uncertainties.

2) We adopt compositional verification to examine the correctness of the joint effort of all the agents and mitigate the computational complexity by introducing an assume-guarantee scheme [9]. Another modification of the $L^{*}$ learning algorithm is developed to generate appropriate assumptions for each supervised agent automatically.

3) In addition to our previous work [12, 13], we further associate synthesized mission plans with appropriate motion plans by presenting a third modification of the $L^{*}$ learning algorithm. Moreover, replanning schemes of the motion plan in the practical environment are also studied.

4) To examine the effectiveness of the design framework, we apply the theoretical results to a practical multi-robot coordination demonstration. It turns out in the experiment that the robots can cooperatively satisfy a request-response and coordination task even the environment possesses uncertainties.

The remainder of this paper is organized as follows. In Section II, we briefly review prior work on multi-agent coordination and application of formal methods. In Section III, we give a brief description of the supervisory control theory and compositional verification within the multi-agent system formalism as well as the $L^{*}$ learning algorithm. Based on the preliminaries, we formulate the multi-agent coordination and control co-design problem and propose an automatic synthesis framework to synthesize appropriate local mission and motion plans for each agent in Section IV. Two modified $L^{*}$ algorithm are presented in Section V to generate appropriate local mission plans via supervisor synthesis and compositional verification. In Section VI, we incorporate the model of the nominal environment with the mission plans to synthesize corresponding motion plans by utilizing a third modified $L^{*}$ algorithm, and online replanning strategies are proposed to address environment uncertainties. We apply the proposed framework to a multi-robot system in order to examine its effectiveness in Section VII, while Section VIII demonstrates the experimental results for the proposed robotic coordination scenario by deploying three robots that are equipped with dedicated wireless communication capabilities, localization cameras, and the proposed supervisors that are implemented as MATLAB StateFlow machines. Concluding remarks and future work are discussed in Section IX.

II Related Work

The past two decades have witnessed the development of performance-guaranteed design of cooperative multi-agent systems, and blooming contributions have been made to addressing various distributed coordination and control purposes, such as consensus [3], flocking [14], rendezvous [15], formation control [5] and cooperative learning [16]. The achievement of the global coordination goals is enforced by Lyapunov stability [14], barrier certificates [4] and game theory [17]. Despite fulfillment of steady-state performance objectives, satisfaction of more complicated and temporal specifications is not investigated in these previous works.

The desire to improve the expressiveness of tasks drives our interest towards formal specifications, including regular languages, linear temporal logic (LTL) and computation tree logic (CTL) formulas [8]. A recent trend of “symbolic planning” [18, 19] has established the standard procedure for synthesizing correct-by-construction controllers for formal specifications by combining abstraction-based approaches [20, 21] with formal methods [22, 23, 24]. However, most of the existing works usually assume full knowledge of the environment. To cope with the uncertain environments, Chen et al. [25] designed a control policy to achieve a surveillance mission by combining formal synthesis methods with automata learning of the environment, whereas Lahijanian et al. [26] employed a multilayered synergistic planner to generate trajectories that partially satisfy an LTL specification in uncertain environments; note that both of the aforementioned works focused on single-agent case.

Although control of a single agent to attain formal specifications is tractable, extensions to the multi-agent case are non-trivial. Filippidis et al. [27] proposed a decentralized control scheme to satisfy local LTL specifications with communication constraints among the agents; and this idea was developed by Guo and Dimarogonas [28] to derive a partially decentralized coordination scheme that decomposed the team into clusters of dependent agents to fulfill local LTL specifications. To cope with computational complexity issues, the results were further extended by Tumova et al. [29] by employing receding horizon planning techniques. Nevertheless, specifying each agent’s individual task is difficult to scale up and usually becomes burdensome for human operators in application.

Our work is most closely related to coordination approaches presented in [1], [30] and [31]. Facing a global LTL specification, Kloetzer and Belta [2] derived a centralized solution and assigned individual tasks for each agent accordingly. Nonetheless, deployment of such approaches suffered from the “state explosion” due to its monolithic design pattern. “Trace-closed” regular language specifications were studied in [1] for automatic deployment of robotic teams. Karimadini and Lin [30] presented necessary and sufficient conditions under which the global tasks can be retrieved by local ones, while Partovi and Lin [32] investigated this problem for CTL specifications. Brandin et al. [33] studied the coordinated planning of multi-agent systems by using an incremental verification approach, whereas Seow et al. [31] investigated the coordination of multi-agent systems from a supervisory control perspective with additional “coordination modules”. These results focused on task allocation and/or design of control policies among multiple agents with known external environment, while in our proposed work, coordination and control co-design in the presence of both system and environment uncertainties are investigated.

III Preliminaries

This section presents preliminaries in automata theory, supervisory control, compositional verification, and a brief introduction of the $L^{*}$ learning algorithm [11]. Throughout the rest of this paper, we use the following notations. Let $\mathbb{N}$ denote the set of non-negative integers. For a finite set $\Sigma$, let $2^{\Sigma}$ and $|\Sigma|$ denote its power set (set of all subsets) and cardinality, respectively. For two sets $\Sigma_{1}$ and $\Sigma_{2}$, $\Sigma_{1}-\Sigma_{2}$ denotes the set-theoretic difference of $\Sigma_{1}$ and $\Sigma_{2}$; $\Sigma_{1}\Delta\Sigma_{2}$ denotes the symmetric difference of of $\Sigma_{1}$ and $\Sigma_{2}$, i.e., $\Sigma_{1}\Delta\Sigma_{2}=(\Sigma_{1}-\Sigma_{2})\cup(\Sigma_{2}-\Sigma_{1})$; and $\Sigma_{1}\Sigma_{2}=\{\sigma_{1}\sigma_{2}|\sigma_{1}\in\Sigma_{1},\sigma_{2}\in\Sigma_{2}\}$, where $\sigma_{1}\sigma_{2}$ stands for the concatenation of two elements $\sigma_{1}$ and $\sigma_{2}$.

III-A Automata and Regular Language Models

For a given finite set (alphabet) of events $\Sigma$, a finite sequence $w$ composing of elements in $\Sigma$, i.e., $w=\sigma_{0}\sigma_{1}\ldots\sigma_{m}$, is called a word over $\Sigma$. We use $\Sigma^{*}$ to denote the Kleene-closure of $\Sigma$ [8], including the empty word $\epsilon$. The length of a word $w\in\Sigma^{*}$ is denoted by $|w|$. A subset of $\Sigma^{*}$ is called a language over $\Sigma$. The prefix-closure of a language $L\subseteq\Sigma^{*}$, denoted as $\overline{L}$, is the set of all prefixes of words in $L$, i.e., $\overline{L}=\{s\in\Sigma^{*}|(\exists t\in\Sigma^{*})[st\in L]\}$. $L$ is said to be prefix-closed if $\overline{L}=L$. For two languages $L_{1},L_{2}\subseteq\Sigma^{*}$, the quotient is the collection of prefixes of words in $L_{1}$ with a suffix that belongs to $L_{2}$, i.e., $L_{1}/L_{2}=\{s\in\Sigma^{*}|(\exists t)[(t\in L_{2})\land(st\in L_{1})]\}$.

To recognize languages over $\Sigma$, the definition of deterministic finite automaton [8] is recalled as follows.

Definition 1** (Deterministic Finite Automaton)**

A deterministic finite automaton (DFA) is a 5-tuple

[TABLE]

where $Q$ is a finite set of states, $\Sigma$ is a finite set of events, $q_{0}\in Q$ is an initial state, $\delta:Q\times\Sigma\to Q$ is a partial transition function and $Q_{m}\subseteq Q$ is the set of the marked (accepting) states.

The transition function $\delta$ can be extended to $\delta:Q\times\Sigma^{*}\to Q$ in the usual manner [7]. We use the notation $\delta(q,s)!$ to denote that the transition $\delta(q,s)$ is defined. A DFA $G$ is said to be accessible if $(\forall q\in Q)(\exists s\in\Sigma^{*})[\delta(q_{0},s)=q]$; $G$ is said to be coaccessible if $(\forall q\in Q)(\exists s\in\Sigma^{*})[\delta(q,s)\in Q_{m}]$; $G$ is said to be trim if it is both accessible and coaccessible [7].

A run of a DFA $G$ on a finite word $w=\sigma_{0}\sigma_{1}\ldots\sigma_{m}\in\Sigma^{*}$, is a sequence of states $Run(w)=q_{0}q_{1}\ldots q_{m+1}\in Q^{*}$ satisfying $q_{i+1}=\delta(q_{i},\sigma_{i})(i=0,1,\ldots,m)$. The language generated by a DFA $G$ is given by $L(G)=\left\{s\in\Sigma^{*}|\delta(q_{0},s)!\right\}$, and the language accepted (recognized) by $G$ is given by $L_{m}(G)=\left\{s\in\Sigma^{*}|s\in L(G),\delta(q_{0},s)\in Q_{m}\right\}$. A language $L\subseteq\Sigma^{*}$ is said to be regular if there exists a DFA $G$ such that $L(G)=\overline{L}$ and $L_{m}(G)=L$. We will focus our study on regular languages throughout the rest of this paper.

The complement language of a regular language $L$ over $\Sigma$ is defined as $coL=\Sigma^{*}-L$. Let $G$ be a DFA accepting $L$, the complete DFA of $G$, denoted as $\tilde{G}$, is defined as follows.

Definition 2** (Complete DFA)**

Let $q_{e}$ be an “error state”. Given a DFA $G=(Q,\Sigma,q_{0},\delta,Q_{m})$, the complete model of $G$ is defined as a DFA $\tilde{G}=(\tilde{Q},\Sigma,q_{0},\tilde{\delta},\{q_{e}\})$, where $\tilde{Q}=Q\cup\{q_{e}\}$, and

[TABLE]

It can be verified that $L_{m}(\tilde{G})=\Sigma^{*}$. The complement DFA $coG$ of $G$ that accepts $coL$, is formed by swapping the marked states of $G$ with its non-marked states and vice versa, i.e., $coG=(\tilde{Q},\Sigma,q_{0},\tilde{\delta},\tilde{Q}-Q_{m})$.

We conclude the review of automata theory by investigating the concurrent operation of two or more DFAs.

Definition 3** (Parallel Composition)**

[9, 7]** Given two finite automata $G_{i}=(Q_{i},\Sigma_{i},q_{i,0},\delta_{i},Q_{i,m})(i=1,2)$, the parallel composition of $G_{1}$ and $G_{2}$, denoted by $G_{1}||G_{2}$, is defined as the finite automata $G_{1}||G_{2}=(Q,\Sigma,q_{0},\delta,Q_{m})$, where $Q=Q_{1}\times Q_{2}$ is the set of states, $\Sigma=\Sigma_{1}\cup\Sigma_{2}$ is the set of events, $q_{0}=(q_{1,0},q_{2,0})$ is the initial state, $Q_{m}=Q_{1,m}\times Q_{2,m}$ is the set of marked states, and the $\delta:Q\times\Sigma\to Q$ is the transition function that is given by:

[TABLE]

Remark 1

It is worth pointing out that parallel composition of more than two finite automata can be defined recursively based on the associativity of parallel composition.

The connection between the behavior of the composed DFA and a local DFA is captured by the “natural projection” from the global event set to the local one. For non-empty event sets $\Sigma$ and $\Sigma^{\prime}$ satisfying $\Sigma^{\prime}\subseteq\Sigma$, the natural projection $P_{\Sigma^{\prime}}:\Sigma^{*}\to\Sigma^{\prime*}$ is inductively defined as: $P_{\Sigma^{\prime}}(\epsilon)=\epsilon$; $P_{\Sigma^{\prime}}(\sigma)=\sigma$ if $\sigma\in\Sigma^{\prime}$; $P_{\Sigma^{\prime}}(s\sigma)=P_{\Sigma^{\prime}}(s)P_{\Sigma^{\prime}}(\sigma)$, $\forall s\in\Sigma^{*},\sigma\in\Sigma$. The set-valued inverse projection $P_{\Sigma^{\prime}}^{-1}:\Sigma^{\prime*}\to 2^{\Sigma^{*}}$ of $P_{\Sigma^{\prime}}$ is defined as $P_{\Sigma^{\prime}}^{-1}(s)=\left\{t\in\Sigma^{*}:P_{\Sigma^{\prime}}(t)=P_{\Sigma^{\prime}}(s)\right\}$.

Let $I=\{1,2,\ldots,n\}$ be an index set. For local event sets $\Sigma_{i}(i\in I)$ and the global event set $\Sigma=\bigcup_{i\in I}\Sigma_{i}$, let $P_{i}$ denote the natural projection from $\Sigma^{*}$ to $\Sigma_{i}^{*}$. The synchronous product of a finite set of regular languages $L_{i}\subseteq\Sigma_{i}^{*}(i\in I)$, denoted by $||_{i\in I}L_{i}$, is defined as follows.

Definition 4** (Synchronous Product)**

[34]** For a finite set of regular languages $L_{i}\subseteq\Sigma_{i}^{*}(i=1,2,\ldots,n)$,

[TABLE]

It can be shown that for $G=||_{i=1}^{n}G_{i}$, $L(G)=||_{i=1}^{n}L(G_{i})$.

The notion of language separability plays an essential role in the rest of the paper and is defined formally as follows.

Definition 5** (Separable Languages)**

[34]** For the local event sets $\Sigma_{i}(i=1,2,\ldots,n)$ and the global event set $\Sigma=\bigcup_{i=1}^{n}\Sigma_{i}$, a language $L\subseteq\Sigma^{*}$ is said to be separable with respect to $\{\Sigma_{i}\}_{i=1}^{n}$ if there exists a set of local languages $L_{i}\subseteq\Sigma_{i}^{*}$ for each $i\leq n$ such that $L=||_{i=1}^{n}L_{i}$.

It has also been shown in [34] that $L\subseteq\Sigma^{*}$ is separable with respect to $\{\Sigma_{i}\}_{i=1}^{n}$ if and only if $L=||_{i=1}^{n}P_{i}(L)=\bigcap_{i=1}^{n}P_{i}^{-1}[P_{i}(L)]$.

Remark 2

For the local event sets $\Sigma_{i}(i\in I)$ and the global event set $\Sigma=\bigcup_{i\in I}\Sigma_{i}$, let $D(\Sigma)=\{(\sigma_{1},\sigma_{2})\in\Sigma\times\Sigma|\exists i\in I,\sigma_{1},\sigma_{2}\in\Sigma_{i}\}$. The independence relation is defined as $I(\Sigma)=\Sigma\times\Sigma-D(\Sigma)$ [35]. It follows from [35] that a language $L\subseteq L(G)$ possesses a non-empty separable sublanguage if and only if $I(\Sigma)$ is transitive.

III-B Supervisory Control Theory

Given a system modeled by a DFA $G=(Q,\Sigma,q_{0},\delta,Q_{m})$, let $\Sigma$ be partitioned into the controllable event set $\Sigma_{c}$ and the uncontrollable event set $\Sigma_{uc}$, i.e., $\Sigma=\Sigma_{c}\dot{\cup}\Sigma_{uc}$. A supervisor [22, 23] $S$ is another DFA over $\Sigma$ with the constraint that each state of $S$ is marked. $S$ operates in parallel with $G$ and modifies the behavior of $G$ by disabling certain controllable events. The behavior of $G$ under control of $S$ is denoted as $L(S||G)$. Given a prefix-closed and non-empty specification language $L=\overline{L}\subseteq L(G)$, there exists a local supervisor $S$ such that $L(S||G)=L$ if and only if $L$ is controllable with respect to $G$ and $\Sigma_{uc}$.

Definition 6** (Controllable Languages)**

[7, 22]** A language $L\subseteq L(G)$ is said to be controllable with respect to $G$ and $\Sigma_{uc}$ (or controllable for short) if $\overline{L}\Sigma_{uc}\cap L(G)\subseteq\overline{L}$.

If the controllability of $L$ fails, a supervisor is synthesized for the supremal controllable (also prefix-closed) sublanguage of $L$, denoted as $\sup C(L)$.

III-C Compositional Verification

We employ a compositional verification procedure to evaluate the coordinated behavior of the multi-agent system. First, we present the concept of “property satisfaction” in the context of formal verification.

Definition 7** (Satisfaction Relation)**

Given a system modeled by a DFA $M=(Q,\Sigma_{M},q_{0},\delta,Q_{m})$ and a regular language (property) that is accepted by a DFA $P=(Q_{P},\Sigma_{P},q_{0,P},\delta_{P},Q_{m,P})$ with $\Sigma_{P}\subseteq\Sigma_{M}$, the system $M$ is said to satisfy $P$, written as $M\models P$, if and only if $\forall t\in L_{m}(M):P_{P}(t)\in L_{m}(P)$, where $P_{P}$ denotes the natural projection from $\Sigma_{M}$ to $\Sigma_{P}$.

Note that when $P$ is represented by a prefix-closed language, the marked languages considered in Definition 7 can be altered by generated languages.

To mitigate the “state explosion” issue arising in verification for systems that consist of multiple components, the assume-guarantee reasoning scheme [9] is employed at this point. In this paradigm, a formula to be checked is a triple $\langle A\rangle M\langle P\rangle$, where $M$ is a system model, $P$ is a property and $A$ is an assumption about $M$’s environment, all of which are represented by a corresponding DFA. The formula holds if whenever $M$ is part of a system satisfying $A$, then the system must guarantee the property $P$, i.e., $\forall E$, $E||M\models A$ implies that $E||M\models P$ [9]. The following theorem provides a DFA characterization of the assume-guarantee satisfaction.

Theorem 1

[9]** $\langle A\rangle M\langle P\rangle$ holds if and only if $q_{e}$ is unreachable in $A||M||\tilde{P}$ ($\tilde{P}$ is the complete DFA of $P$).

The assume-guarantee scheme summons a series of symmetric and/or asymmetric proof rules to ease the reasoning when the system $M$ consists of multiple components, i.e., $M=||_{i=1}^{n}M_{i}$. We apply the symmetric proof rule, namely SYM-N [9], for the compositional verification, where $A_{i}$ is an assumption about $M_{i}$’s environment and $coA_{i}$ is the complement DFA of $A_{i}$.

[TABLE]

A central notion of the compositional verification is the weakest assumption, which is defined formally as follows.

Definition 8** (Weakest Assumption for $\Sigma_{i,IF}$)**

(Adapted from [9]) Let $M=||_{i=1}^{n}M_{i}$ be a system with local alphabets $\Sigma_{i}(i=1,2,\ldots,n)$, $P$ be a DFA representation of a property and $\Sigma_{i,IF}$ be a specified interface alphabet of $M_{i}$ to its environment. The weakest assumption $A_{i}^{w,\Sigma_{i,IF}}$ of $M_{i}$ over the alphabet $\Sigma_{i,IF}$ for property $P$ is a DFA such that: 1) $\Sigma(A_{i}^{w,\Sigma_{i,IF}})=\Sigma_{i,IF}$; 2) for any $M_{-i}=||_{j\in I,j\neq i}M_{j}$, $\langle true\rangle M_{i}||(P_{i,IF}(M_{-i}))\langle P\rangle$ if and only if $\langle true\rangle M_{-i}\langle A_{i}^{w,\Sigma_{i,IF}}\rangle$, where $P_{i,IF}$ is the natural projection from $\bigcup_{i=1}^{n}\Sigma_{i}$ to $\Sigma_{i,IF}$.

Since then we require that $\Sigma_{P}\subseteq\bigcup_{i\in I}\Sigma_{i}$, and we use the notation $A_{i}^{w}$ to denote the weakest assumption for component $M_{i}$ over $\Sigma_{i,IF}$ being set to $\Sigma_{A_{i}}$ such that $\Sigma_{A_{i}}\subseteq(\bigcap_{i\in I}\Sigma_{i})\cup\Sigma_{P}(i\in I)$.

III-D $L^{*}$* Learning Algorithm*

Angluin [11] developed the $L^{*}$ learning algorithm (abbreviated as $L^{*}$ algorithm hereafter) for solving the problem of identifying an unknown regular language $U$ over an alphabet $\Sigma$ and of constructing a minimal DFA111By “minimal” we mean that the obtained DFA contains the least number of states. that accepts it. Interested readers are referred to [11] for more details.

The $L^{*}$ algorithm interacts with a minimally adequate Teacher, henceforth deemed as the Teacher, that answers two types of questions. The first type is referred to as membership queries, i.e., the Teacher justifies whether or not a word $s\in\Sigma^{*}$ belongs to $U$; the second type is a conjecture, in which the $L^{*}$ algorithm constructs a DFA $M$ and the Teacher justifies $L_{m}(M)=U$ or not; the Teacher returns a counterexample $c\in L_{m}(M)\Delta U$ whenever the conjecture is denied.

In order to construct a conjectured DFA $M$, the $L^{*}$ algorithm incrementally collects information about a finite collection of words in $\Sigma^{*}$ and records their membership status in an observation table. The observation table is a three-tuple $(S,E,T)$, where $S$ and $E$ are a set of prefix-closed and suffix-closed words over $\Sigma$, respectively, and $T:(S\cup S\Sigma)E\to\{0,1\}$ is the membership function that maps words in $s\in(S\cup S\Sigma)$ onto $1$ if they are members of $U$, otherwise it returns [math]. The observation table can be viewed as a 2-dimensional array whose rows are labeled by words $s\in S\cup S\Sigma$ and whose columns are labeled by symbols $e\in E$. The entries in the labeled rows and columns are evaluated by the function $T(se)$. If $s\in S\cup S\Sigma$, then the row function $row(s)$ denotes the finite function $f$ from $E$ to $\{0,1\}$ defined by $f(e)=T(se)$. The following two properties are essential in the $L^{*}$ algorithm.

Definition 9** (Closeness and Consistency)**

[11*]** An observation table is said to be closed if $(\forall s\in S)(\forall\sigma\in\Sigma)$ $[\exists s^{\prime}\in S:row(s\sigma)=row(s^{\prime})]$. It is said to be consistent if $(\forall s_{1},s_{2}\in S:row(s_{1})=row(s_{2}))(\forall\sigma\in\Sigma)[row(s_{1}\sigma)=row(s_{2}\sigma)]$. *

If an observation table is not closed, then $s\sigma$ is added to $S$ and $T$ is updated to make it closed where $s\in S$ and $\sigma\in\Sigma$ are the elements for which no $s^{\prime}\in S$ exists. If an observation table is not consistent, then there exist $s_{1},s_{2}\in S$, $\sigma\in\Sigma$ and $e\in E$ such that $row(s_{1})=row(s_{2})$ but $T(s_{1}\sigma e)\neq T(s_{2}\sigma e)$; to make it consistent, $\sigma e$ is added to $E$ and $T$ is updated.

Once an observation table is both closed and consistent, a candidate DFA $M(S,E,T)=(Q,\Sigma,q_{0},\delta,Q_{m})$ over the alphabet $\Sigma$ is constructed as follows: $Q=\left\{{row(s):s\in S}\right\}$, $q_{0}=row(\epsilon)$, $Q_{m}=\left\{{row(s):(s\in S)\land(T(s)=1)}\right\}$, and $\delta(row(s),\sigma)=row(s\sigma)$.

The Teacher takes $M$ as a conjecture and if $L_{m}(M)=U$, the Teacher returns “True” with the current DFA $M$; otherwise, the Teacher returns “False” with a counterexample $c\in L_{m}(M)\Delta U$. The $L^{*}$ algorithm adds all the words in $\overline{\{c\}}$ to $S$ and iterate the entire procedure to update a new closed and consistent observation table. The following theorem asserts that the sequence of DFAs constructed by the $L^{*}$ algorithm to be consistent222A DFA $M$ is said to be consistent with the function $T$ if for every $s\in S\cup S\Sigma$ and $e\in E$, $\delta(q_{0},se)\in Q_{m}$ if and only if $T(se)=1$. with $T$ after each counterexample examination is strictly increasing in the number of states.

Theorem 2

[11]** If $(S,E,T)$ is closed and consistent, and $M(S,E,T)$ is a DFA constructed from $(S,E,T)$. Let $(S^{\prime},E^{\prime},T^{\prime})$ be the updated closed and consistent observation table if a counterexample $t$ is added to $(S,E,T)$. If $M(S,E,T)$ has $n$ states, then the DFA $M(S^{\prime},E^{\prime},T^{\prime})$ constructed from $(S^{\prime},E^{\prime},T^{\prime})$ has at least $n+1$ states.

The correctness and finite convergence of the $L^{*}$ algorithm are assured by the following theorem.

Theorem 3

[11]** Given an unknown regular language $U\subseteq\Sigma^{*}$, the $L^{*}$ algorithm eventually terminates and outputs an DFA isomorphic to the minimal one accepting $U$. Moreover, if $n$ is the number of states of the minimal DFA accepting $U$ and $m$ is an upper bound on the length of any counterexample provided by the Teacher, then the total running time of the $L^{*}$ algorithm is bounded by a polynomial in $m$ and $n$.

IV Problem Formulation and Overall Approach

IV-A Automata-based Agent and Environment Models

We study the coordination and control of multiple agents moving in a shared and uncertain environment that admits uncertain elements. For a multi-agent system $G$ that consists of $n$ agents, we model the mission executions of agent $G_{i}(i\in I)$ as a DFA

[TABLE]

The local mission set $\Sigma_{i}$ is partitioned into local controllable missions $\Sigma_{i,c}$ and local uncontrollable missions $\Sigma_{i,uc}$. We are interested in the generated language of $G_{i}$ and we assume that $Q_{i,m}=Q_{i}$. The global events, controllable and uncontrollable events are given by $\Sigma=\bigcup_{i\in I}\Sigma_{i}$, $\Sigma_{c}=\bigcup_{i\in I}\Sigma_{i,c}$ and $\Sigma_{uc}=\Sigma-\Sigma_{c}=\bigcap_{i\in I}\Sigma_{i,uc}$, respectively. The collective behavior of the system $G$ is captured by $G=||_{i\in I}G_{i}$. For a given mission $\sigma\in\Sigma$, $I_{\sigma}=\{i\in I|\sigma\in\Sigma_{i}\}$. $|I_{\sigma}|>1$ suggests that all agents $G_{i}$ with $i\in I_{\sigma}$ cooperate to accomplish the mission $\sigma$.

All the agents are assumed to move in a shared environment that is partitioned into $N$ regions, and we assume that there are $N_{d}$ doors placed among these regions. Two adjacent regions in the environment may be connected by one or more doors. The cooperative multi-agent system is provided with the nominal environment a priori, which is modeled as a 4-tuple

[TABLE]

where $V=\{v_{1},v_{2},\ldots,v_{N}\}$ is the set of labels for the partitioned regions, $\longrightarrow_{\mathcal{E}_{0}}\subseteq V\times V$ is the adjacency relation among the regions, $D=\{d_{1},d_{2},\ldots,d_{N_{d}}\}$ is the set of labels for the doors, $F_{D}:V\times V\to 2^{D}$ is a partial mapping such that for all $(v,v^{\prime})\in\longrightarrow_{\mathcal{E}_{0}}$, $F_{D}(v,v^{\prime})\subseteq D$ represents all the possible doors that connect the adjacent regions $v$ and $v^{\prime}$, whereas $F_{D}(v,v^{\prime})=\emptyset$ implies that $v$ and $v^{\prime}$ are not connected by any doors.

The motion capabilities of agent $G_{i}(i\in I)$ within the nominal environment $\mathcal{E}_{0}$ are abstracted as a trim DFA:

[TABLE]

where $V$ and $D$ are defined in $\mathcal{E}_{0}$, $v_{i,0}\in V$ is the initial region of agent $G_{i}$, $V_{m}=V$ and the motion transition $\delta^{m}_{i}$ is defined as follows:

[TABLE]

i.e., an agent can move to an adjacent region whenever there is a door connecting the two regions.

The uncertainty of the multi-agent system arises in two aspects. Firstly, the practical environment $\mathcal{E}$ may differ from the nominal one $\mathcal{E}_{0}$, in the sense that some transitions in $F_{D}$ may become unaccessible. Secondly, the mission capabilities of $G_{i}$’s need not be given a priori.

IV-B Coordination of Cooperative Multi-agent Systems

The integration of mission and motions of the agent $G_{i}$ is captured by the following local labeling mapping

[TABLE]

that specifies a region in $V$ in which a mission in $\Sigma_{i}$ shall be performed.

The coordination of the agents accounts for both mission and motion plans. Formally, an integrated mission-motion plan is defined as follows.

Definition 10** (Integrated Local Plans)**

A local integrated mission-motion plan for agent $G_{i}(i\in I)$ is a prefix-closed language $LP_{i}\subseteq(V\cup\Sigma_{i})^{*}$ such that

$LP_{i}(0)=v_{i,0}$; 2. 2.

If $LP_{i}(k)\in\Sigma_{i}$ and $LP_{i}(k-1)\in V$, then $LP_{i}(k-1)\in\pi_{i}(LP_{i}(k))$; otherwise, $\pi_{i}(LP_{i}(k-1))=\pi_{i}(LP_{i}(k))$ 3. 3.

$P_{V}(LP_{i})\subseteq Run\left[L(G^{m}_{i})\right]$, where $P_{V}$ denotes the natural projection from $V\cup\Sigma_{i}$ to $V$ and $Run\left[L(G^{m}_{i})\right]=\bigcup_{s\in L(G^{m}_{i})}Run(s)$.

We use $L_{i}^{mo}=P_{V}(LP_{i})$ to denote the motion plan component of an integrated local plan $LP_{i}$ for agent $G_{i}$, whereas $L_{i}^{mi}=P_{\Sigma}(LP_{i})$ stands for the mission plan component of $LP_{i}$, where $P_{\Sigma}$ is the natural projection from $V\cup\Sigma_{i}$ to $\Sigma_{i}$.

Our main objective is concerned with the synthesis of local mission plans and corresponding motion plans for each agent such that a global mission can be accomplished.

Problem 1

Given a cooperative multi-agent system $G$ that consists of $n$ agents with local mission DFA $G_{i}$ and motion DFA $G_{i}^{m}(i\in I)$ within the nominal environment $\mathcal{E}_{0}$, and a prefix-closed global mission $L\subseteq\Sigma^{*}$ whose independence relation (cf. Remark 2) is transitive, solve the following problems:

Mission assignment: systematically find a feasible local mission specification $L^{mi}_{i}$ for each agent $G_{i}$; 2. 2.

Mission planning: synthesize a series of local supervisors $S_{i}(i\in I)$ such that $L(S_{i}||G_{i})=L_{i}^{mi}$; 3. 3.

Motion planning: synthesize local motion plans $L_{i}^{mo}(i\in I)$ such that the combination of $L^{mi}_{i}$ and $L^{mo}_{i}$ forms an integrated local plan $LP_{i}$; 4. 4.

Mission-motion integration: $||_{i\in I}LP_{i}\models L$.

IV-C Overview of the Approach

Without loss of generality, we assume that $L\subseteq L(G)$. We propose a two-layer formal synthesis framework to solve Problem 1 via “divide-and-conquer”. The synthesis procedure of the framework is depicted in Fig. 1. In addition, regular language learning algorithms are utilized in the proposed framework to guarantee the performance of the cooperative multi-agent system in the presence of system and/or environment uncertainties. The fact that $\Sigma\cap D=\emptyset$ enables us to solve the mission and motion planning sub-problems in a modular fashion, which can be summarized as iterative execution of the following procedure.

1) Mission decomposition: Obtain a prefix-closed and locally feasible mission specification $L_{i}$ for agent $G_{i}(i\in I)$.

2) Local supervisor synthesis: Given the mission specification $L_{i}$, we use a modified $L^{*}$ algorithm to automatically synthesize a local supervisor $S_{i}$ such that $L(S_{i}||G_{i})=\sup C_{i}(L_{i})$, where $\sup C_{i}$ stands for the supremal controllable sublanguage with respect to $G_{i}$ and $\Sigma_{i,uc}$.

3) Compositional verification: We employ a compositional verification strategy to justify whether or not all the controlled agents can fulfill the global mission. Specifically, we apply the assume-guarantee paradigm by setting $M_{i}:=S_{i}||G_{i}(i\in I)$ as component modules and $L$ as the property to be verified. The verifier returns a counterexample $t\subseteq\Sigma^{*}$ that indicates the violation of $L$ when the compositional verification fails. Such counterexample $t$ is applied for the re-synthesis of the local supervisors until no more counterexamples are detected. Afterwards, local mission plans $L^{mi}_{i}(i\in I)$ are obtained.

4) Automatic motion planning: Based on the synthesized mission plans $L^{mi}_{i}$, corresponding motion plans $L^{mo}_{i}$ are generated by incorporating $G^{m}_{i}(i\in I)$ such that the combination of $L^{mi}_{i}$ and $L^{mo}_{i}$ forms a valid integrated local plan $LP_{i}$.

5) Counterexample-guided motion replanning: Agent $G_{i}$ implements $LP_{i}$ in the practical environment $\mathcal{E}_{0}$; once there exists a mismatch between $\mathcal{E}$ and $\mathcal{E}_{0}$ that makes the current motion plan $L^{mo}_{i}$ is infeasible, a counterexample is automatically generated to refine $L^{mo}_{i}$ such that a new integrated plan $LP_{i}$ can be executed by $G_{i}$.

The following sections illustrate the mission and motion planning layers respectively.

V Learning-based Compositional Synthesis of Mission Plans

This section concerns with the (offline) mission planning of the proposed framework shown in in Fig. 1. Synthesis of mission plans $L^{mi}_{i}(i\in I)$ consists of two stages: first, we exploit the local mission capabilities $\Sigma_{i}$ to develop feasible local missions and mission supervisors; next, we compositionally verify the joint performance of the coordination of the mission plans by using the assume-guarantee scheme [9].

V-A Initiation of the Mission Plans

We originate the generation of local missions $L_{i}(i\in I)$ by setting $L_{i}=P_{i}(L)$. The local feasibility of $L_{i}$ is assured by the following theorem.

Theorem 4

Given a cooperative multi-agent system $G$ that consists of $n$ agents $G_{i}(i\in I)$ and a non-empty and prefix-closed specification $L\subseteq L(G)$, languages $L_{i}:=P_{i}(L)(i\in I)$ satisfy $L_{i}\subseteq L(G_{i})$ and $L_{i}=\overline{L_{i}}$.

Proof:

From Definition 4, the prefix-closeness of $L$ implies that $P_{i}(L)$ is prefix-closed. Thus we obtian $L_{i}=\overline{L}_{i}$. Next, according to Definitions 3 and 4,

[TABLE]

which completes the proof. ∎

V-B Automatic Synthesis of Local Mission Supervisors

We aim to synthesize a maximally permissive [7] local mission supervisor $S_{i}$ that drives $G_{i}$ to fulfill $L_{i}(i\in I)$. According to Definition 6, applying directly the $L^{*}$ algorithm to synthesize an appropriate supervisor for agent $G_{i}(i\in I)$ is infeasible when full knowledge of $G_{i}$ is not given a priori. To overcome this computational burden, we modify the algorithm and propose a learning-based algorithm, namely the $L^{*}_{LS}$333The subscript “LS” stands for “local synthesis”. algorithm, for agent $G_{i}$ to learn $\sup C_{i}(L_{i})$ with the local controllability information $\Sigma_{i}=\Sigma_{i,c}\dot{\cup}\Sigma_{i,uc}$ rather than $G_{i}$.

The local mission supervisors are constructed on the basis of illegal words. A mission $s\in L(G_{i})$ is said to be illegal if $s\not\in L_{i}$. A local mission $st\in L(G_{i})$ is said to be uncontrollably illegal if it becomes illegal due to an uncontrollable suffix, i.e., $s\in L_{i}$ , $t\in\Sigma_{i,uc}^{*}$ and $st\not\in L_{i}$. Let $C_{i}$ be the collection of uncontrollably illegal behaviors of agent $G_{i}(i\in I)$. Define $D_{ui}(\cdot)$ as an operator to collect words that are formed by discarding the uncontrollable suffixes of mission behaviors in $C_{i}$, i.e., $D_{ui}(C_{i})=\left\{s\in L(G_{i})|(\exists t\in\Sigma_{uc}^{*})[st\in C_{i}]\right\}.$

From Section III.D, the $L^{*}$ algorithm sequentially constructs a series of observation tables to generate a correct DFA that recognizes an unknown regular language. This idea is inherited by the $L^{*}_{LS}$ algorithm and the observation table is formed with help of $C_{i}$. Specifically, let $C_{i}^{j}$ denote the set of uncontrollably illegal behavior after the $j$-th update of the observation table in the $L^{*}$ algorithm; thus $C_{i}^{j+1}=\left\{s_{j}\right\}\cup C_{i}^{j}$ if a new uncontrollably illegal behavior $s_{j}$ is added to $C_{i}^{j}$.

The main difference between the $L^{*}$ and $L_{LS}^{*}$ algorithms lies on the membership queries and generation of counterexamples. For $t\in\Sigma_{i}^{*}$, we let $T_{i}^{j}(t)(j\in\mathbb{N})$ be the membership function for $G_{i}(i\in I)$. Initially, the Teacher justifies the membership of $t$ with respect to $L_{i}$,

[TABLE]

and for $j>1$, rather than answering the membership question with respect to the unknown $\sup C_{i}(L_{i})$, the Teacher provides answers for the following queries:

[TABLE]

Furthermore, due to the lack of prior knowledge of $G_{i}$, we define the following sequence $\{K_{j}\}(j\in\mathbb{N})$ to facilitate the generation of appropriate counterexamples.

[TABLE]

With slightly abusing the notations, we also use $K_{j}$ to denote the DFA that recognizes the language $K_{j}(j\in\mathbb{N})$. Let $M_{j}=M(S^{j},E^{j},T^{j}_{i})$ be the DFA that is consistent with membership function $T^{j}_{i}$, a word $t\in\Sigma_{i}$ is a counterexample of the $L^{*}_{LS}$ algorithm with respect to agent $G_{i}(i\in I)$ if

[TABLE]

The $L^{*}_{LS}$ algorithm can be viewed as an execution of the $L^{*}$ algorithm by using membership queries in (6)(7) while generating counterexamples by examining (9). Details of the $L^{*}_{LS}$ algorithm are presented in Algorithm 1.

V-C Correctness of the $L^{*}_{LS}$ Algorithm

The following lemma helps us investigate the correctness and finite convergence properties of the $L_{LS}^{*}$ algorithm.

Lemma 1

(Paraphrased from [36]) If $L_{i}$ and $L(G_{i})$ are regular languages, then $\sup C_{i}(L_{i})$ can be computed iteratively as follows.

[TABLE]

If there exists $N\in\mathbb{N}$ such that $K_{N+1}=K_{N}$, then $\sup C_{i}(L_{i})=K_{N}$. Moreover, if $L_{i}$ is prefix-closed, then $\sup C_{i}(L_{i})$ is also prefix-closed and can be computed directly as

[TABLE]

We now proceed to the correctness of the $L^{*}_{LS}$ algorithm. In fact, comparing (10) with the dynamical membership queries stated in (6)(7) and the counterexample-related iteration (8), we observe that initially, for $i\in I$, (10) is identical to (8), and $T^{1}_{i}(t)$ is consistent with $K_{1}=L_{i}$. Furthermore, when the iteration step $j\geq 2$, counterexamples are generated and based on which $C^{j}_{i}$ is formed. When no more counterexamples are generated, the set $C^{j}_{i}$ eventually becomes identical to $L(G_{i})-L_{i}$, which includes all the local illegal and uncontrollably illegal behaviors and it turns out that the language consistent with $T^{j}_{i}$ is

[TABLE]

Note that the right side of (12) coincides with the results obtained in (11), which implies that the output of the $L^{*}_{LS}$ algorithm is indeed $\sup C_{i}(L_{i})$, provided that it is convergent.

Next we will prove that the $L^{*}_{LS}$ algorithm synthesizes $\sup C_{i}(L_{i})$ within a finite number of iterations. From Algorithm 1, there are two kinds of “counterexamples” that are used by the $L^{*}_{LS}$ algorithm: counterexamples used to make an observation table $T^{j}_{i}$ closed and consistent (lines 4-15), and counterexamples generated by the Teacher (9) to construct a new observation table $T^{j+1}_{i}$ (lines 17-20). We denote $D_{i}$ as the collection of the “true” counterexamples that are generated according to (9), while $D^{\prime}_{i}$ is used to denote the set of counterexamples that help make an observation table closed and consistent.

Consider an observation table $T=(S^{j}_{i},E^{j}_{i},T^{k}_{i})$ with the corresponding DFA $M(S^{j}_{i},E^{j}_{i},T^{k}_{i})=M$, where $S^{j}_{i}$ and $E^{j}_{i}$ are the pre-defined $S$ and $E$ after the $j$-th counterexample from $D_{i}$ has been added to the table, and $T^{k}_{i}$ denotes the current membership function after $k$-th counterexample in $D^{\prime}_{i}$ has been added to update it. Let $n_{k,j}$ denote the number of states of DFA $M$, $n_{k}$ denote the number of states of the minimal DFA that is consistent with $T^{k}_{i}$, and $n^{\uparrow}$ denote the number of states of the minimal DFA that recognizes $\sup C_{i}(L_{i})$. According to membership queries (6)(7) and Lemma 1, the sequence of DFAs that are consistent with $T_{i}^{k}$ finally recognizes $\sup C_{i}(L_{i})$, which implies that $n_{k}\to n^{\uparrow}$ (with respect to $k$) and the convergence is achieved within a finite number of iterations.

In addition, from Theorem 2, $n_{k,j}\leq n_{k}$ for all $j\in\mathbb{N}$. Moreover, it is clear that $\left\{n_{k,j}\right\}$ is a monotonically increasing sequence (with respect to $j$). Therefore, $n_{k,j}\to n_{k}$ for a fixed $k$ (with respect to $j$) is enforced by its monotonicity and upper-boundedness. The fact that $n_{k}\to n^{\uparrow}$ thus yields that $n_{k,j}\to n^{\uparrow}$.

The above discussion in fact proves the correctness and finite convergence properties of the $L^{*}_{LS}$ algorithm, as summarized in the following theorem.

Theorem 5

For a non-empty, prefix-closed and locally feasible mission specification $L_{i}\subseteq L(G_{i})$ for agent $G_{i}(i\in I)$, the $L^{*}_{LS}$ algorithm with dynamical membership queries (6) and (7), and counterexample generated from (9), converges to a local mission supervisor $S_{i}$ such that $L(S_{i}||G_{i})=\sup C_{i}(L_{i})$. Moreover, the $L_{LS}^{*}$ algorithm can always construct the correct $S_{i}$ after a finite number of counterexample tests.

Remark 3

It follows from Theorem 3 that the $L^{*}_{LS}$ algorithm also admits a polynomial-time computational complexity. Compared to the conventional supervisor synthesis algorithms proposed in [7] and [36], the presented $L_{LS}^{*}$ algorithm requires no prior knowledge of the plant.

V-D Automated Compositional Verification via Learning

Let $L^{mi}_{i}:=\sup C_{i}(L_{i})$ be the (initial) local mission plan of agent $G_{i}(i\in I)$ in the cooperative multi-agent system. In case that the global mission $L$ is prefix-closed and separable with respect to $\{\Sigma_{i}\}_{i\in I}$, the mission assignment and planning for each agent can be solved in a modular manner by synthesizing local supervisors independently to fulfill the initial local specifications $L_{i}=P_{i}(L)(i\in I)$ using the $L^{*}_{LS}$ algorithm, since according to [34], separability of $L$ implies $L=||_{i\in I}P_{i}(L)$. Nonetheless, whenever $L$ fails to be separable, it is non-trivial to determine whether or not the concurrent execution of $L^{mi}_{i}(i\in I)$ satisfies the global mission $L$. To automate the assume-guarantee strategy, we propose another modification of the $L^{*}$ algorithm, namely the $L^{*}_{CV}$444The subscript “CV” stands for “compositional verification”. algorithm, to learn appropriate and weakest local assumptions for each supervised agent

[TABLE]

Let $M=||_{i\in I}M_{i}$ denote the mission performance of the controlled cooperative multi-agent system, $A_{i}$ denote an assumption about $M_{i}$’s environment. With slightly abusing the notations, we use $L$ and $coL$ to denote the DFA that recognizes $L$ and its complement language, respectively. The $L^{*}_{CV}$ algorithm checks $M\models L$ via the assume-guarantee proof rules SYM-N. A two-layered implementation of the $L^{*}_{CV}$ algorithm is depicted in Fig. 2.

As shown in Fig. 2, in the first layer, the $L^{*}_{CV}$ algorithm deploys $n$ local Teachers, each of which corresponds to an controlled agent $M_{i}(i\in I)$, to learn the appropriate and weakest assumption $A_{i}$ for $M_{i}$. At the $j$-th iteration step, the $L_{CV}^{*}$ algorithm learns an appropriate assumption $A_{i}^{j}$ for the controlled agent $M_{i}$, by querying the agent and by reviewing the results of the previous iteration. As the $L_{CV}^{*}$ algorithm executes the learning procedure iteratively, it incrementally (in the sense of the number of states) constructs a sequence of assumption DFAs $\{A_{i}^{j}\}_{j\in\mathbb{N}}$ for $M_{i}$, which converges to the DFA that recognizes the weakest assumption $A_{i}^{w}$ whose event set is constrained to be $\Sigma_{A_{i}}$ (cf. Section III.C).

The implementation of the $L_{CV}^{*}$ algorithm relies on the following lemma.

Lemma 2

(Adapted from [9]) Given $t\in\Sigma^{*}$, $i\in I$ and a regular property $L$, $t\in L(A_{i}^{w})$ if and only if $\langle\mathcal{DFA}(t)\rangle M_{i}\langle L\rangle$ holds, where $\mathcal{DFA}(t)$ is a trim DFA such that $L(\mathcal{DFA}(t))=L_{m}(\mathcal{DFA}(t))=\overline{t}$.

Suggested by Lemma 2, each local Teacher of the $L_{CV}^{*}$ algorithm answers the following membership queries to construct local assumption DFAs for each controlled agent $M_{i}$: for $i\in I$ and $t\in\Sigma^{*}$,

[TABLE]

In addition to the membership queries (14), the Teacher of the $L^{*}_{CV}$ algorithm justifies the conjecture $\langle A_{i}^{j}\rangle M_{i}\langle L\rangle$ rather than $L(A_{i}^{j})=L(A_{i}^{w})$. Once the Teacher denies the conjecture, a counterexample $t\in\Sigma^{*}$ is proposed by the Teacher, and the $L^{*}_{CV}$ algorithm adds $P_{A_{i}}(t)$ and all its prefixes back to the local iteration loop to update the observation tables, where $P_{A_{i}}$ is the natural projection from $\Sigma^{*}$ to $\Sigma_{A_{i}}^{*}$.

Once the local learning loop of the $L^{*}_{CV}$ algorithm terminates, we collect a family of local assumptions $A_{i}:=A_{i}^{w}(i\in I)$. In addition to the $n$ local Teachers, the $L^{*}_{CV}$ algorithm deploys Teacher $n+1$ in the second layer in the framework shown in Fig. 2 to justify whether $L(coA_{1}||\cdots||coA_{n})\subseteq L$ or not. If Teacher $n+1$ returns “True”, the synthesis framework terminates with the conclusion that $||_{i\in I}M_{i}\models L$. Otherwise, Teacher $n+1$ returns “False” with a counterexample $t\in\Sigma^{*}$. The $L^{*}_{CV}$ algorithm then determines whether or not the global mission $L$ is indeed violated by the collective behavior of $M$, which is performed by simulating $t$ on each composed DFA $M_{i}||coL(i\in I)$ and by checking whether or not $t$ can be accepted. If $t$ is not a violating trace for at least one agent $M_{i}$, we treat $t$ in the same way in the first layer and use $t$ to re-construct the local assumption $A_{i}$ for controlled agent $M_{i}$. Otherwise, $t$ turns out to be a common violating word of all agents and the controlled cooperative multi-agent system $||_{i\in I}M_{i}$ indeed violates $L$. As shown in Fig. 1, undesired mission behaviors emerge in the joint execution of synthesized mission plans $L^{mi}_{i}$ for agent $G_{i}(i\in I)$; therefore, the re-synthesis of local mission plans is triggered (cf. Section V.E). The correctness and termination properties of the $L^{*}_{CV}$ algorithm are summarized in the following theorem.

Theorem 6

[9]** For the global mission $L$ and controlled agents $M_{1},M_{2},\cdots,M_{n}$, the $L_{CV}^{*}$ algorithm implemented by the framework shown in Fig. 2 with the proof rules SYM-N terminates within finite number of iterations and correctly returns whether or not $||_{i\in I}M_{i}\models L$.

V-E Counterexample-guided Re-synthesis of Mission Plans

Our proposed mission planning scheme explores the re-synthesis of the local mission plans after a mission-violating counterexample $t$ is provided by the compositional verification procedure. The re-synthesis is accomplished by the following steps: first,

[TABLE]

next, to apply the $L^{*}_{LS}$ algorithm for the re-synthesis of the local mission supervisor, it is desired to provide agent $G_{i}(i\in I)$ with a prefix-closed mission specification; this requirement is fulfilled by setting

[TABLE]

where $coL^{temp}_{i}=\Sigma_{i}^{*}-L^{temp}_{i}$ is the complement language of $L^{temp}_{i}$. The obtained $L_{i}$ is used as the new initial local mission for agent $G_{i}$ to update the new local mission supervisor $S_{i}(i\in I)$ with the $L^{*}_{LS}$ algorithm.

Since it has been shown in the previous subsections that both the $L^{*}_{LS}$ and $L_{CV}^{*}$ algorithms possess finite convergence, we mainly focus on evaluating the performance of the proposed mission planning schemes in this subsection. We introduce the notion of separate controllability to characterize the solutions of the multi-agent mission planning.

Definition 11

Given the cooperative multi-agent system that consists of $n$ agents $G_{i}$ with $\Sigma_{i,c}\subseteq\Sigma_{i}$ being the local controllable events, $i\in I$, a prefix-closed language $L\subseteq\Sigma^{*}$ is said to be separately controllable with respect to $\Sigma_{i},\Sigma_{i,uc}$ and $G_{i}$ if

$L=||_{i\in I}P_{i}(L)$; 2. 2.

$P_{i}(L)$* is controllable with respect to $G_{i}$ and $\Sigma_{i,uc}$.*

We assert that the separate controllability is a sufficient and necessary condition for the existence of solutions of the cooperative multi-agent mission planning.

Theorem 7

Given a cooperative multi-agent system $G$ that consists of $n$ agents $G_{i}(i\in I)$ with local controllable events $\Sigma_{i,c}$ and local uncontrollable events $\Sigma_{i,uc}$, and a non-empty and prefix-closed global mission specification $L\subseteq L(G)$, there exists a series of local mission supervisors $S_{i}(i\in I)$ for each agent $G_{i}$ such that $L(S_{i}||G_{i})=P_{i}(L)$ and $||_{i\in I}L(S_{i}||G_{i})=L$ if and only if $L$ is separately controllable with respect to $\Sigma_{i}$, $\Sigma_{i,uc}$ and $G_{i}$.

Proof:

($\Leftarrow$) When $L\subseteq L(G)$ is separately controllable with respect to $\Sigma_{i},\Sigma_{i,uc}$ and $G_{i}$, Theorem 4 yields that $P_{i}(L)\subseteq L(G_{i})$ is prefix-closed; whereas Definition 11 suggests that $P_{i}(L)$ be controllable with respect to $G_{i}$ and $\Sigma_{i,uc}$, which implies that for each $i\in I$, there exists a local supervisor $S_{i}$ such that $L(S_{i}||G_{i})=P_{i}(L)$ [36]. Therefore, $||_{i\in I}L(S_{i}||G_{i})=||_{i\in I}P_{i}(L)=L$ is guaranteed according to the separability requirement of Definition 11.

($\Rightarrow$) Conversely, when local supervisors $S_{i}(i\in I)$ exist such that $L(S_{i}||G_{i})=P_{i}(L)$ and $||_{i\in I}L(S_{i}||G_{i})=L$, $L=||_{i\in I}P_{i}(L)$ trivially holds. Furthermore, since $L(S_{i}||G_{i})=P_{i}(L)$ is a controlled behavior for agent $G_{i}$, it is clearly controllable with respect to $G_{i}$ and $\Sigma_{i,uc}$. ∎

The following theorem states that in general, the separate controllability is a strictly stronger notion than the combination of global controllability and separability.

Theorem 8

For the cooperative multi-agent system $G$ that consists of $G_{i}(i\in I)$, if a non-empty prefix-closed specification language $L\subseteq L(G)$ is separately controllable with respect to $\Sigma_{i},\Sigma_{i,uc}$ and $G_{i}$, then $L$ is separable with respect to $\{\Sigma_{i}\}_{i\in I}$ and is controllable with respect to $G$ and $\Sigma_{uc}$.

Proof:

First, by Definition 11, the separate controllability of $L$ implies that $L=||_{i\in I}P_{i}(L)$, which assures the separability of $L$. Next we show that $L$ is globally controllable. In fact, $P_{i}(L)$ is prefix-closed and controllable with respect to $G_{i}$ and $\Sigma_{i,uc}$, i.e.

[TABLE]

it follows from the monotonicity of $P_{i}^{-1}$ that

[TABLE]

Since

[TABLE]

we have

[TABLE]

Note that the last inclusion always holds for any $i\in I$. Therefore

[TABLE]

where the last equality holds according to Definition 4. From the definitions of $\Sigma_{c}$ and $\Sigma_{uc}$, the above equation is equivalent to

[TABLE]

which enforces the global controllability of $L$. ∎

Based on the aforementioned properties of separately controllable languages, the following theorem is established to illustrate the correctness of the proposed mission planning scheme.

Theorem 9

The mission planning procedure shown in Fig. 1 terminates and returns local mission supervisors $S_{i}$ as well as local mission plans $L^{mi}_{i}(i\in I)$ for each agent such that the collective behaviors of the cooperative multi-agent system $G$ achieve a separately controllable sublanguage of $L$, within a finite number of iterations.

Proof:

When $L$ is separable, the local mission plans are given by $L^{mi}_{i}:=\sup C_{i}(P_{i}(L))$ and the correctness of the proposed mission planning procedure trivially holds.

When $L$ is not separable, we define

[TABLE]

as the set of prefix-closed and separable sublanguages of $L$. Under the assumption imposed by Remark 2, $S(L)\neq\emptyset$.

At each iteration step of the $L^{*}_{CV}$ algorithm, a counterexample $t$ is actually a word that belongs to $||_{i\in I}L^{mi}_{i}-L$. The first step (15) of the counterexample-guided replanning thus eliminates all the observationally indistinguishable local mission behaviors with respect to $t$ from the local mission plan $L^{mi}_{i}$ and generates a temporal mission language $L_{i}^{temp}$; while the second step (16) in fact computes the supremal prefix-closed sublanguage [36] of $L_{i}^{temp}(i\in I)$. Thus,

[TABLE]

Since during the iterative execution of the mission planning, $L_{i}$ is used as an updated mission specification for the $L^{*}_{LS}$ algorithm; thus, the updated mission plans of agent $G_{i}$, denoted as $\tilde{L}^{mi}_{i}(i\in I)$, after the generation of $t$, will be

[TABLE]

which implies that the joint effort of the $L^{*}_{LS}$ and $L^{*}_{CV}$ algorithms generates the following “monotonic” sequence of local mission plans for each agent $G_{i}$:

[TABLE]

When no more counterexamples are produced by the $L^{*}_{CV}$ algorithm, with slightly abusing the notations, we can write that

[TABLE]

thus $\tilde{L}\in S(L)$. Furthermore, $\tilde{L}^{mi}_{i}$, generated by the $L^{*}_{LS}$ algorithm, is controllable with respect to $\Sigma_{i,uc}$ and $G_{i}$. Hence according to Definition 11, $||_{i\in I}\tilde{L}^{mi}_{i}$ forms a non-empty and separately controllable sublanguage of $L$, which solves the mission planning of the cooperative multi-agent system. ∎

Remark 4

We use $L^{mi}_{i}$ to denote the synthesized mission plans for agent $G_{i}(i\in I)$ hereafter.

VI Motion Planning of Cooperative Agents

VI-A Automatic Generation of Motion Plans

After the design of feasible local missions $L^{mi}_{i}(i\in I)$, the motion planning problem concentrates on finding a set of motion plans $L^{mo}_{i}$ associated with each $L^{mi}_{i}$ such that the integrated mission-motion plans $LP_{i}(i\in I)$ solve Problem 1. A local motion plan actually consists of two parts: a local motion plan $L^{mo}_{i}\subseteq V^{*}$ that enumerates all the regions visited by the agent, and a local door profile $D^{mo}_{i}\subseteq D^{*}$ associated with $L^{mo}_{i}$ that records all possible doors through which the agents shall pass. It is desired that the local motion plan is adequate, which is defined as follows.

Definition 12** (Adequate Plans)**

A local motion plan $L^{mo}_{i}$ for agent $G_{i}(i\in I)$ is said to be adequate if

$L^{mo}_{i}\models\pi_{i}(L^{mi}_{i})$; 2. 2.

$L^{mo}_{i}\subseteq Run\left[L(G^{m}_{i})\right]$.

From Definition 12, synthesis of the local motion plan starts by exploiting the mission-motion integration relation $\pi_{i}(i\in I)$ in (5). The intuition behind Definition 12 is that $L^{mo}_{i}$ shall obey restrictions imposed not only by $L^{mi}_{i}$, but by $G^{m}_{i}$ as well (adequacy).

It is clear from (5) that the mission-motion integration mapping $\pi_{i}$ maps the prefix-closed language $L^{mi}_{i}$ over $\Sigma_{i}$ into a prefix-closed language $\pi_{i}(L^{mi}_{i})$ over $V$. To efficiently compute an adequate motion plan for each agent (which is not known a priori), we employ a third modification of the $L^{*}$ learning algorithm, termed as the $L^{*}_{MP}$555The subscript “MP” stands for “motion planning”. algorithm, to pursue an adequate local motion plan. Specifically, the Teacher of the $L^{*}_{MP}$ algorithm is designed to determine the following membership queries for agent $G_{i}$: for $i\in I$ and $t\in V^{*}$:

[TABLE]

where $\mathcal{DFA}(t)$ is defined similarly to the membership queries (14) for the $L^{*}_{CV}$ algorithm, except that the underlying DFA is defined over $V$. Besides justifying the membership queries (20), the Teacher of the $L^{*}_{MP}$ algorithm answers the conjecture $L^{mo}_{i}\subseteq Run\left[L(G^{m}_{i})\right]$. If the conjecture is denied, a counterexample $t\in V^{*}$ is produced. Since $L^{mo}_{i}\subseteq Run\left[L(G^{m}_{i})\right]$ is false, we know that $t$ witnesses a difference between $L^{mo}_{i}$ and $Run\left[L(G^{m}_{i})\right]$; therefore, it is returned to the $L^{*}_{MP}$ algorithm to update the motion plan $L^{mo}_{i}$.

The correctness and termination properties of the $L^{*}_{MP}$ algorithm can be summarized as the following theorem.

Theorem 10

Given the local mission plan $L^{mi}_{i}$ and the mission-motion integration mapping $\pi_{i}$, the $L^{*}_{MP}$ algorithm terminates and correctly constructs an adequate local motion plan $L^{mo}_{i}(i\in I)$.

Proof:

(Correctness) The Teacher of the $L^{*}_{MP}$ algorithm is designed according to the two properties in Definition 12. When a counterexample is generated, the counterexample in fact represents a word in the symmetric difference between $\pi_{i}(L^{mi}_{i})$ and $Run\left[L(G^{m}_{i})\right]$; therefore, if no more counterexample is generated, the current learned DFA $L^{mo}_{i}$ (with slightly abusing the notations) satisfies both of the requirements of Definition 12, which guarantees the correctness.

(Termination) At any iteration step, after a local motion plan DFA $L^{mo}_{i}$ is conjectured, the $L^{*}_{MP}$ algorithm reports whether or not $L^{mo}_{i}$ is adequate and terminates, or continues the construction of $L^{mo}_{i}$ by providing new counterexamples. By Theorem 3, the learning procedure eventually terminates at some iteration step $j\in\mathbb{N}$, at that time, the $L^{*}_{MP}$ algorithm produces an adequate $L^{mo}_{i}$. ∎

Furthermore, the door profile associated with the synthesized local motion plan $L^{mo}_{i}$ is obtained as

[TABLE]

where the operator $\rm Word$ computes all the corresponding words $s\in D^{*}$ by treating words in $L^{mo}_{i}$ as runs of $G^{m}_{i}$, i.e., ${\rm Word}(L^{mo}_{i})=\{s\in L(G^{m}_{i})|Run(s)\in L^{mo}_{i}\}$.

VI-B Counterexample-guided Replanning in Uncertain Environments

We aim to implement the integrated plans $\{LP_{i}\}_{i\in I}$ in the real environment $\mathcal{E}$ rather than the nominal environment characterized by $\mathcal{E}_{0}$, which is used for generating motion plans and door profiles. As mentioned in Section IV.A, feasible transitions among adjacent regions in $\mathcal{E}_{0}$ may become infeasible in $\mathcal{E}$ since some doors that are supposed to be open are closed. During the online coordination of the cooperative multi-agent systems, the underlying agents may detect the real door mapping $F^{\mathcal{E}}_{D}$ and the real region transition diagram $\delta^{\mathcal{E}}_{i}$ through sensing capabilities and communication with each other. Here we assume that the motion capacities

[TABLE]

of agent $G_{i}(i\in I)$, under the restriction of $\mathcal{E}$, are also captured by a trim DFA. Based on the online-acquired knowledge of the environment, we develop a new algorithm to address the environment uncertainty, whose outputs include both the feasible integrated plan $LP^{\mathcal{E}}_{i}$ and the associated door profile $D^{m}_{i}$ for agent $G_{i}(i\in I)$ moving and performing missions in $\mathcal{E}$.

As detailed in Algorithm 2, the implementation of $LP_{i}$ in the real environment $\mathcal{E}$ starts with the synthesized local plans $LP_{i}$ and corresponding door profiles $D^{mo}_{i}$. For $i\in I$, Algorithm 2 first enumerates (line 2) $LP_{i}$ as a collection of $K$ prefix-closed words over $V\cup\Sigma_{i}$, i.e., $LP_{i}=\bigcup_{k=1}^{K}\overline{LP_{i}^{k}}$, while if $LP_{i}^{k}$ admits a cycle such that $LP_{i}^{k}=uv^{*}$ for some $u\in\Sigma^{*}$ and $v\in\Sigma^{*}-\{\epsilon\}$, we replace $LP_{i}^{k}$ by $uv$. Next for each $LP^{k}_{i}$, we proceed to the investigation of two types of environment uncertainties. On the one hand (lines 7-10), if two adjacent regions in $LP_{i}$ are connected by multiple doors whereas some of the doors are closed, we require the agent to use alternative (redundant) doors to accomplish the motion plan and hence the integrated local plan $LP_{i}$ remains the same, while the door profile $D^{m}_{i}$ is formed by discarding all the words in $D^{mo}_{i}$ that contain the symbols of closed doors. On the other hand (lines 12-17), when two consecutive regions $v$ and $v^{\prime}$ that are supposed to be visited by agent $G_{i}$ are not connected by any doors in $\mathcal{E}$, the assumption that $G^{\mathcal{E}}_{i}$ is a trim DFA inspires us to replace the motion transition $vv^{\prime}$ by a sequence of “intermediate” regions $v_{1},v_{2},\ldots,v_{p}$ such that

[TABLE]

afterwards, we replace all the transition $vv^{\prime}$ in $LP_{i}$ by $vv_{1}v_{2}\ldots v_{p}v^{\prime}$ to construct $LP^{\mathcal{E}}_{i}$, and the door profile is updated accordingly.

VII Case Study: A Robotic Coordination Example

We examine the effectiveness of our proposed learning-based synthesis framework with a multi-robot coordination case study, whose scenario is shown in Fig. 3.

VII-A Description of the Multi-robot Coordination Scenario

As depicted in Fig. 3, the cooperative robotic team consists of three robots, namely $G_{1}$, $G_{2}$ and $G_{3}$, all of which have identical communication and self-localization capabilities. In addition, $G_{2}$ is assumed to be equipped with rescue and fire-fighting capabilities. We assume that all doors are equipped with a spring and are kept closed whenever there is no force to keep them open. Initially, the three robots are positioned in Room 1. Room 2 and Room 3 are accessible using the one-way door $D_{2}$, or the two-way doors $D_{1}$ and $D_{3}$, respectively. The nominal environment of the robots is depicted in Fig. 4

From (3), the nominal environment $\mathcal{E}_{0}$ is characterized by:

• •

$V=\{R_{1},R_{2},R_{3}\}$, where $R_{j}$ stands for Room $j(j=1,2,3)$;

• •

$\longrightarrow_{\mathcal{E}_{0}}=\{(R_{1},R_{2}),(R_{1},R_{3}),(R_{2},R_{1}),(R_{3},R_{1})\}$;

• •

$D=\{D_{1}^{l},D_{1}^{r},D_{2},D_{3}\}$, where $D_{1}^{l}$ and $D_{1}^{r}$ represent the left and right half of $D_{1}$, respectively;

• •

$F_{D}(R_{1},R_{2})=\{D_{1}^{r},D_{2}\}$, $F_{D}(R_{2},R_{1})=\{D_{1}^{r}\}$, $F_{D}(R_{1},R_{3})=\{D_{1}^{l},D_{3}\}$, and $F_{D}(R_{3},R_{1})=\{D_{1}^{l},D_{3}\}$.

For $i\in I=\{1,2,3\}$, the motion DFA $G^{m}_{i}=(V,D,v_{i,0},\delta^{m}_{i},V)$ for robot $G_{i}$ is then given by: $v_{i,0}=R_{1}$, $\delta^{m}_{i}(R_{1},D_{1}^{r})=\delta^{m}_{i}(R_{1},D_{2})=R_{2}$, $\delta^{m}_{i}(R_{1},D_{3})=\delta^{m}_{i}(R_{1},D_{1}^{l})=R_{3}$, $\delta^{m}_{i}(R_{3},D_{3})=\delta^{m}_{i}(R_{3},D_{1}^{l})=R_{1}$. Thus, the DFA representation of $G^{m}_{i}$ is given as follows:

The coordination mission assigned to this multi-robot system requires that after a fire-extinguishing alarm from $R_{2}$ is triggered, $G_{2}$ needs to go to $R_{2}$ and come back immediately to $R_{1}$ through the two-way door $D_{1}$ that can only be opened with the cooperation of $G_{1}$ and $G_{3}$. To open $D_{1}$ efficiently, either $G_{1}$ or $G_{3}$ goes to $R_{3}$ from the two-way door $D_{3}$, while the other stays in $R_{1}$ to synchronously open $D_{1}$ and waits for $G_{2}$ to return to $R_{1}$. Afterwards, both $G_{1}$ and $G_{3}$ move backwards to close $D_{1}$ and all three robots assemble in $R_{1}$ for next service request.

VII-B Automata-based Characterization of Multi-robot Systems

The global mission events of the multi-robot system are given by $\Sigma=\bigcup_{i=1}^{3}\Sigma_{i}$, and are listed in Table 1.

We assume that the prior knowledge of all local mission event sets $\Sigma_{i}(i=1,2,3)$ is accessible to the supervisor:

[TABLE]

Furthermore, for the purpose of supervisory control, we assume that $\Sigma_{1,uc}=\{h_{1},G_{2}inR_{1}\}$, $\Sigma_{2,uc}=\{h_{2},D_{1}open\}$ and $\Sigma_{3,uc}=\{h_{3},G_{2}inR_{1}\}$.

As discussed in the previous subsection, the following two regular languages $L^{spe}_{1}$ and $L^{spe}_{2}$ are introduced to capture the two requirements for the multi-robot system, respectively:

[TABLE]

The overall global mission specification for the multi-agent system is then $L=L^{spe}_{1}||L^{spe}_{2}$. Our design objective is to synthesize valid local integrated plans $LP_{i}=(L^{mi}_{i},L^{mo}_{i})$ for each robot $G_{i}(i=1,2,3)$ such that $||_{i=1}^{3}LP_{i}\models L$ holds in the real environment $\mathcal{E}$.

VII-C Synthesis of Local Plans

We first follow the framework shown in Fig. 1 to synthesize local mission plans $L^{mi}_{i}$ and local mission supervisors $S_{i}$ for robot $G_{i}(i=1,2,3)$. The initial local missions $L_{i}$ are obtained by $L_{i}=P_{i}(L)(i=1,2,3)$, whose DFA representations are shown in Figures 6 and 7, respectively.

Next, we aim to apply the $L_{LS}^{*}$ algorithm for the synthesis of the local mission supervisor for robot $G_{i}$ to fulfill $L_{i}(i=1,2,3)$. For instance, a candidate supervisor $S_{2}$ demonstrated in Fig. 8 is synthesized to achieve $\sup C_{2}(L_{2})$ for robot $G_{2}$, which is identical to $L_{2}$. Local mission supervisors $S_{1}$ and $S_{3}$ can be developed in a similar manner, and it turns out that $\sup C_{1}(L_{1})=L_{1}$ and $\sup C_{3}(L_{3})=L_{3}$.

Afterwards, we present $M_{i}=S_{i}||G_{i}$ to the $L^{*}_{CV}$ algorithm, and a counterexample that indicates a violation of $L$ emerges. We examine this counterexample and it turns out that when one of the robots $G_{1}$ or $G_{3}$ stays in $R_{1}$, the other robot must stay in $R_{3}$. By adding this counterexample back to the $L^{*}_{CV}$ algorithm, we update the local specifications according to Section V.E, the $L^{*}_{LS}$ algorithm derives the new local mission supervisors as shown in Figures 9 and 10, respectively.

Intuitively, the updated local mission plans $S_{1}$ and $S_{3}$ explicitly specify that robot $G_{1}$ stays in $R_{1}$, while robot $G_{3}$ enters $R_{3}$ such that $D_{1}$ can be opened jointly. We insert the new $M_{i}=S_{i}||G_{i}$ to the $L^{*}_{CV}$ algorithm to justify whether the collective behaviors of the local supervisors cooperatively satisfy $L$; and in this time the $L^{*}_{CV}$ algorithm reports no more counterexample, which implies that $S_{i}(i=1,2,3)$ drives $G_{i}$ to accomplish an appropriate local mission. Therefore, Fig. 9 and Fig. 10 are also DFA representations of local mission plans $L^{mi}_{i}(i=1,2,3)$.

Finally, we apply the $L^{*}_{MP}$ algorithm stated in Section VI to construct local motion plan $L^{mo}_{i}$ that is associated with $L^{mi}_{i}(i=1,2,3)$, respectively. Towards this end, the local motion plans are established in terms of DFAs:

Based on the local motion plans obtained as shown in Fig. 11, we can construct the integrated local plan $LP_{i}$ for each robot $G_{i}$. Such construction relies on the local mission-motion integration mapping $\pi_{i}(i=1,2,3)$, which is defined as follows:

Robot $G_{1}$:

[TABLE] 2. 2.

Robot $G_{2}$:

[TABLE] 3. 3.

Robot $G_{3}$:

[TABLE]

Fig. 12, Fig. 13 and Fig. 14 depict the integrated local plans $LP_{1}$, $LP_{2}$ and $LP_{3}$, respectively.

It is worth pointing out that, all the $LP_{i}$’s are designed with respect to $\mathcal{E}_{0}$, and when implementing $LP_{i}$’s in the practical environment $\mathcal{E}$, the robots may encounter with uncertainties. In this case, the robots shall automatically react to the uncertain environment by online replanning their motion plans. For example, in case the door $D_{3}$ is broken and cannot be opened when $G_{3}$ needs to return to $R_{1}$, $G_{3}$ shall then return to $R_{1}$ through $D_{1}$.

VIII Experimental Results

VIII-A Experiment Setup

We now proceed to the experimental validation of the theoretical results. The proposed supervisors, implemented as MATLAB StateFlow machines, are tested and evaluated on a team composed by three robots.

The experimental setup for testing the derived supervisors is composed by three main elements, described respectively as follows.

VIII-A1 Localization System

The localization system is constructed on the basis of the Aruco library [37] and provides the status of each robot (position and orientation) and each door (open or close) with a frame-rate of $\sim 20$Hz. Each robot is equipped with a unique marker. The localization software detects the position and the orientation of each marker, providing the position data through a UDP socket. The information concerning the position of the robots and the status of each door is encoded using the JSON format. Furthermore, each robot is able to request its position or another robot’s position.

The localization software is based on a multi-threading architecture in order to minimize the delay on the transmission of the position information:

• •

The main thread implements a UDP server waiting for information requests from the robots. The response contains the robot id, its position and orientation and the status of all the doors.

For example, the position of the robot $G_{1}$ along with the status of the three doors is represented as follows: $\{G1:[+0460.86,+0113.43,+0079.15,0,0,1]\}$.

• •

The second thread computes the position of each marker and updates the list of detected markers along with their position and orientation. The camera used on the localization system has a resolution of 640x480 and a frame-rate of $\sim 30$ frames per second.

Figure 15 shows the output of the localization system.

VIII-A2 Local supervisors

Each of the three supervisors is implemented as a StateFlow machine and manages a pre-defined robot of the team.

The logic implemented follows the theoretical approach described in Section VII. The transition between the possible states is based on the occurrence of one of the pre-defined events, e.g., the opening of a door. The list of possible events is represented in Table I.

The communication between the robot and the corresponding StateFlow machine is realized using a wireless module. The TCP protocol is chosen to provide a reliable exchange of messages.

As an illustrative example, Figures 16 and 17 show the information transition between the robot and the local plan, as well as the StateFlow implementation of the local plan $LP_{2}$ for robot $G_{2}$, respectively.

VIII-A3 Ground Robots

The hardware of each robot is designed as a multi-layered architecture.

• •

The low-level system (LL board), based on xMOS processors [38], is responsible to interact with the sensors and the actuators (Fig. 18).

Thanks to the hard real-time performance of the xMOS devices, the low-level system provides deterministic real-time access to all the sensors and actuators connected to the processor.

• •

The high-level system (HL board) is constructed on the basis of the BeagleBone board and is responsible to interact with the corresponding local plan (Fig. 19). The main purpose of the high-level board is to provide a tool for developing high-level control systems, delegating the low-level real-time board for the interaction with the sensors and the actuators.

Taking advantage of the localization system (Fig. 15), each robot is equipped with a unique marker (Fig. 20) that is convenient to be recognized by the localization system. The coordinates of the four corners of the marker are used to estimate the position (in terms of pixel coordinates) of the center of the marker, along with its orientation.

VIII-B Demonstration Results

The flow chart in Fig. 21 describes the interaction between the local plan (represented in DFAs) and the corresponding ground robot.

After the reception of the START signal, the High-level board of the agent initializes the communication system and sends the first request to its local plan DFA. The local plan DFA responds by sending the command back to the HL board. The HL board then reads data from the sensors and computes control actions interacting with the LL board. After reaching a desired position, the HL board sends an ACK (acknowledge) message back to the supervisor. Once the local plan supervisor receives the ACK message, it replies by sending the next action to the HL board of the agent. For example, we implement the local plan $LP_{2}$ (Fig. 13) for robot $G_{2}$ in the real experiment environment. The path followed by robot $G_{2}$, as defined by the local motion plan $L^{mo}_{2}$, is shown in Fig. 22.

In Figure 23, we record the waypoints visited by robot $G_{2}$ and plot the actual path. The cloud of points corresponds to the instants in which the robot $G_{2}$ reached a pre-defined waypoint and waited for the next command sent from the local supervisor. The position of the robot is expressed in pixel coordinates. The differences between the planned path and the real path are due to hardware limitations, in particular to the difference between the localization rate and the update rate of the servo motors. This problem can be overcome by integrating additional sensors such as Inertial Measuring Unit (IMU) or encoders in order to provide a higher data rate for position estimation, as well as an estimation of the robot’s position even when the marker is not detected. A sensor fusion algorithm is currently under development to overcome both limitations.

IX Conclusion and Future Work

In this paper, based on a formal design approach, we present a learning-based automatic synthesis framework to solve the coordination and control co-design problem of cooperative multi-agent systems. Starting from an automata-based characterization of each agent’s dynamics as well as the shared environment in which all the agents perform their mission and motion behaviors, our proposed framework solves the mission and motion planning sub-problems in a hierarchical architecture. We develop three modified $L^{*}$ algorithms to synthesize the local mission supervisors, to check the joint efforts of the mission executions via compositional verification techniques, and to synthesize motion plans corresponding to the mission plans. In addition, we also present another algorithm that adaptively replans the mission and motions so that environment uncertainties can be resolved. It has been shown that the proposed synthesis framework can accomplish the global task even if the agents’ models are not given a priori. Computational and software tools are also developed to incorporate automatic supervisor synthesis with inter-robot communication in an effort to implement the framework. A demonstration example of multi-robot coordination to achieve a request-response team mission is presented to justify the effectiveness of the proposed framework. Future work includes combining the proposed learning-based automatic synthesis framework with robustness requirements to deal with possible faults.