This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

Continuous Execution of High-Level Collaborative Tasks for Heterogeneous Robot Teams

Amy Fang, Tenny Yin, Jiawei Lin and Hadas Kress-Gazit Sibley School of Mechanical and Aerospace Engineering, Cornell University, Ithaca, NY, 14853 USA. {axf4, yy389, jnl77, hadaskg}@cornell.edu. This work is supported by the NDSEG Fellowship Program.
Abstract

We propose a control synthesis framework for a heterogeneous multi-robot system to satisfy collaborative tasks, where actions may take varying duration of time to complete. We encode tasks using the discrete logic LTLψ, which uses the concept of bindings to interleave robot actions and express information about relationship between specific task requirements and robot assignments. We present a synthesis approach to automatically generate a teaming assignment and corresponding discrete behavior that is correct-by-construction for continuous execution, while also implementing synchronization policies to ensure collaborative portions of the task are satisfied. We demonstrate our approach on a physical multi-robot system.

I Introduction

This paper presents a framework to generate decentralized controllers and synchronization signals, when needed, for a team of heterogeneous robots to satisfy a collaborative task. We consider tasks in which the user requires specific actions to be performed, but does not have requirements on the number or type of robots needed to satisfy a task. For example, in a warehouse environment, the user may want to move a pallet and then pick up a package from the pallet. Depending on the number of available robots and their capabilities, the robots may decide to collaborate to satisfy the task, or perform it by themselves. For instance, there may be a mobile manipulator that can perform both actions on its own, or, if it cannot handle a heavy pallet but there is a stationary manipulator that can, the robots will team up so that one moves the pallet and then the other picks up the package.

In our previous work [1], we introduced the logic LTLψ that allows us to capture such tasks, and proposed a framework that transforms an LTLψ task to high-level controllers. The logic uses bindings to allow users to specify the relationship between robots and parts of the task without providing explicit assignments or constraints on the number of robots required. In [1], the synthesized behavior assumes actions are discrete and treated as instantaneous. However, in physical systems, robots may execute actions with varying duration, such as picking up an object or navigating to an adjacent room. As a result, the synthesized behaviors may violate parts of the specification when executed by the robots. For example, consider a task that requires a surveillance robot to monitor a room only if other robots are present. In the symbolic controller, the two robots can both be outside the room, then immediately be in the room in the next step of their behavior. However, when the robots execute this desired behavior, it is extremely unlikely that they make the transition into the room at the exact same time - any mismatch of timing will cause the task to fail.

In addition, under the instantaneous action assumption of [1], tasks of the form “all robots must enter the room at the same time” and “at least one robot must enter the room” can be solved by assuming all robots with that binding move; however, under the varying action duration assumptions, tasks such as “all robots must enter the room at the same time” are unrealistic and cannot be synthesized. We modify the synthesis algorithms in [1] to explicitly look for solutions of the form “at least one robot” when such specifications are given,

To address these issues, in this paper we define the semantics and synthesize symbolic correct-by-construction controllers for LTLψ tasks such that the continuous-time behavior of the robots is still guaranteed to satisfy the specification during execution.

I-A Related Work

There is a wealth of literature in task assignment and scheduling for multi-robot systems. Multi-robot task allocation problems are often treated as optimization problems [2, 3, 4], such as the multiple traveling salesman problem [5] or the vehicle routing problem [6]. To mitigate the challenges of finding an exact solution, common approximate methods are used to solve the problem, such as learning algorithms, heuristics and meta-heuristics [7] [8], and contract net protocols [9] [10]. Coalition formation algorithms allow robots to automatically form teams to execute a task. Approaches include swarm algorithms [11] and multi-stage coalition formation [12], where the authors provide a two-stage approach to prune for a satisfying coalition.

The aforementioned approaches adopt a more generalized representation of tasks that are agnostic to the specific characteristics of each task, with the primary objective being to map agents to tasks. Each task is abstracted with certain constraints associated with it, such as cost or number of agents required. While these methods enable efficient task allocation algorithms, they do not account for the temporal dependencies and sequences of actions within the task itself. For describing temporally extended tasks, temporal logics can be useful; they allow users to rigorously define temporally extended tasks that may require complex action sequences and constraints. These logics define tasks with symbolic abstractions of the given continuous system. For multi-robot systems, existing work has extended Linear Temporal Logic (LTL) [13, 14, 15] and Signal Temporal Logic (STL) [16] [17] to encode tasks that require multiple robots to execute.

To ensure the satisfaction of multi-robot temporal logic specifications in continuous time, a common approach is to encode the task in STL, which allows for discrete-time continuous signals. For example, in [18], the authors synthesize coordinated trajectories of a heterogeneous multi-robot team to satisfy a global task written in STL. They also introduce integral predicates to provide a quantitative metric for the cumulative progress of the tasks. The type of coordination that can be encoded only includes accumulation (e.g. data collection), as opposed to highly collaborative tasks that require strict synchronization. To address strict synchronization constraints, the authors of [19] propose an event-based synchronization approach in which robots execute local LTL specifications and send synchronization requests when needed. This removes the necessity to synchronize at every discrete step, thus increasing efficiency. However, this work assumes that each robot is assigned a local specification a priori, as opposed to collectively satisfying a global task.

In [20], the authors address the problem of synthesizing controllers for a multi-agent system by extending Capability Temporal Logic (CaTL), which is a fragment of STL, to CaTL+. To ensure satisfiability, they encode two layers of logic, one for individual trajectories and one for the team trajectory. The controllers for each agent are then automatically synthesized by solving a centralized two-step optimization problem. For synchronization requirements, each task includes a counting proposition to indicate the timesteps in which synchronization must happen. The task explicitly encodes the number of capabilities required for each part of the task. In our work, we use LTLψ to define multi-agent tasks, which is an LTL-based grammar we first proposed in [1]. The grammar allows users to define tasks based on actions required instead of the number of agents/capabilities (e.g. “move the pallet and then pick up the package, irrespective of how many agents perform which actions”). In our work, we provide guarantees about the satisfaction of continuous controllers while using a discrete LTL-based logic. In this way, we can maintain the discrete abstraction of actions without any information about their specific timings.

To take into account the fact that actions may have varying durations, the authors in [21] generate reactive hybrid controllers for LTL tasks such that the continuous behavior of the robots are safe. The authors abstract actions with timing constraints by using initiation and completion propositions, and add constraints in the specification for activating these propositions. The specification also includes constraints to ensure collision avoidance across robots. While this approach accounts for collision avoidance, it does not consider collaborative tasks and therefore also does not account for any necessary synchronization constraints. [22] uses synchronization skeletons to coordinate a homogeneous swarm of robots to collectively satisfy a task. The task contains both a macro specification that describes the behavior of a group of robots, and a micro specification for individual robots to satisfy. To ensure the behavior satisfies the specification in the continuous space (i.e. when robots are between two regions), the authors propose an iterative method of synthesizing labeled transition systems, then removing unsafe transitions and adding safety formulas until a valid labeled transition system is found. Rather than an iterative synthesize-then-check approach, our work aims to automatically abstract continuous actions and synthesize symbolic controllers that are already correct-by-construction for continuous execution.

Contributions: In this paper, we propose a framework for control synthesis for continuous execution of collaborative tasks, where actions may take varying duration of time to complete. Based on [1], we use LTLψto encode such tasks and present a synthesis approach to automatically generate a teaming assignment and corresponding symbolic behavior that is correct-by-construction during continuous execution, while also ensuring synchronization requirements are satisfied for collaborative portions of the task. We demonstrate our approach on a physical multi-robot system.

II Preliminaries

II-A Linear Temporal Logic

LTL formulas are constructed from atomic propositions APAP, where πAP\pi\in AP are Boolean variables [23]. The atomic propositions represent an abstraction of robot actions. For example, cameracamera captures a robot taking a picture.

Syntax: We use the following syntax to define an LTL formula:

φ::=π|¬φ|φφ|φ|φ𝒰φ\varphi::=\pi\ |\ \neg\varphi\ |\ \varphi\vee\varphi\ |\ \bigcirc\varphi\ |\ \varphi\ \mathcal{U}\ \varphi

where ¬\neg and \vee are Boolean operators (“not” and “or”, respectively), and \bigcirc and 𝒰\mathcal{U} (“next” and “until”, respectively) are temporal operators. Using these, we can also define conjunction φφ\varphi\wedge\varphi, implication φφ\varphi\Rightarrow\varphi, eventually φ=True𝒰φ\Diamond\varphi=\text{True}\ \mathcal{U}\ \varphi, and always φ=¬¬φ\Box\varphi=\neg\Diamond\neg\varphi.

Semantics: The semantics of an LTL formula φ\varphi are defined over an infinite trace σ=σ(0)σ(1)σ(2)\sigma=\sigma(0)\sigma(1)\sigma(2)..., where σ(i)\sigma(i) is the set of APAP that are true at step ii. We use σφ\sigma\models\varphi to denote that the trace σ\sigma satisfies LTL formula φ\varphi.

Intuitively, φ\bigcirc\varphi is satisfied if φ\varphi is satisfied in the next step of the sequence; φ\Diamond\varphi is satisfied if φ\varphi is true at some step in the sequence; φ\Box\varphi is satisfied if φ\varphi is true at every step in σ\sigma; φ1𝒰φ2\varphi_{1}\ \mathcal{U}\ \varphi_{2} is satisfied if φ1\varphi_{1} remains true until φ2\varphi_{2} becomes true. See [23] for the full semantics.

II-B Büchi Automata

An LTL formula φ\varphi can be translated into a Nondeterministic Büchi Automaton that accepts infinite traces if and only if they satisfy φ\varphi. A Büchi automaton is a tuple =(Z,z0,Σ,δ,F)\mathcal{B}=(Z,z_{0},\Sigma_{\mathcal{B}},\delta_{\mathcal{B}},F), where ZZ is the set of states, z0Zz_{0}\in Z is the initial state, Σ\Sigma_{\mathcal{B}} is the input alphabet, δ:Z×Σ×Z\delta_{\mathcal{B}}:Z\times\Sigma_{\mathcal{B}}\times Z is the transition relation, and FZF\subseteq Z is a set of accepting states. An infinite run of \mathcal{B} over a word σ=σ1σ2σ3Σ\sigma=\sigma_{1}\sigma_{2}\sigma_{3}...\in\Sigma_{\mathcal{B}} is an infinite sequence of states z=z0z1z2z=z_{0}z_{1}z_{2}... such that (zi1,σi,zi)δ(z_{i-1},\sigma_{i},z_{i})\in\delta_{\mathcal{B}}. A run is accepting if and only if Inf(zz) F\cap\ F\neq\emptyset, where Inf(zz) is the set of states that appear in zz infinitely often [24].

III Definitions

III-A Actions

We categorize the actions the robots can execute into two types, instantaneous and non-instantaneous. For example, the action of taking a picture is considered instantaneous; in contrast, the action of moving between rooms is non-instantaneous.

Each action is abstracted as an atomic proposition (AP) π\pi, and its corresponding completion proposition, πc\pi_{c}. π\pi is true at σ(i)\sigma(i) iff the action associated with π\pi is being executed at position ii in the trace; πcAP\pi_{c}\in AP is true at σ(i)\sigma(i) iff the action associated with π\pi has been completed at position ii in the trace. For example, roomAroomA indicates that the robot is currently moving towards room A; roomAcroomA_{c} indicates the robot has finished executing the action roomAroomA and is currently in room A.

The set of all APAP is composed of the subsets APinstAP_{inst} and APnoninstAP_{non-inst}, which are the sets of propositions representing instantaneous actions and non-instantaneous actions, respectively. Formally, an action is instantaneous iff T(π,πc)=0T(\pi,\pi_{c})=0, where TT is the timing function that outputs the amount of time it takes for the action to be executed; thus, πcAPinst\pi_{c}\in AP_{inst}. Similarly, an action is considered non-instantaneous iff T(π,πc)0T(\pi,\pi_{c})\neq 0. For these types of actions, πcAPnoninst\pi_{c}\in AP_{non-inst}. For example, for the action of beeping, T(beep,beepc)=0T(beep,beep_{c})=0 and therefore beepcAPinstbeep_{c}\in AP_{inst}. In contrast, T(roomA,roomAc)0T(roomA,roomA_{c})\neq 0 (i.e. moving into room A takes time), so roomAcAPnoninstroomA_{c}\in AP_{non-inst}.

Note that, for synchronization purposes, we assume that robots can coordinate such that they can execute an action simultaneously, so all π\pi are in the set of APinstAP_{inst}. For example, roomAcAPnoninstroomA_{c}\in AP_{non-inst} but roomAAPinstroomA\in AP_{inst}; beep,beepcAPinstbeep,beep_{c}\in AP_{inst} (note that, for instantaneous actions, π\pi and πc\pi_{c} have equivalent meanings).

III-B Robot Model

Based on our prior work [25], each robot jj is modeled based on its set of capabilities, Λj={λ1,,λk}\Lambda_{j}=\{\lambda_{1},...,\lambda_{k}\}. Each capability is a weighted transition system λ=(X,x0,AP,Δ,,𝒲)\mathcal{\lambda}=(X,x_{0},AP,\Delta,\mathcal{L},\mathcal{W}), where XX is a finite set of states, x0Xx_{0}\in X is the initial state, APAP is the set of atomic propositions representing the actions the capability can execute, ΔX×X\Delta\subseteq X\times X is a transition relation, :X2AP\mathcal{L}:X\rightarrow 2^{AP} is the labeling function, and 𝒲:Δ0\mathcal{W}:\Delta\rightarrow\mathbb{R}_{\geq 0} is the cost function assigning a weight to each transition. The cost function is predefined by the user and can represent execution time, power usage, etc.

A robot model AjA_{j} is the cross product of its capabilities: Aj=λ1××λkA_{j}=\lambda_{1}\times...\times\lambda_{k} such that Aj=(S,s0,APj,γ,L,W)A_{j}=(S,s_{0},AP_{j},\gamma,L,W). S=X1××XkS=X_{1}\times...\times X_{k} is the set of states, s0Ss_{0}\in S is the initial state, APj=i=1kAPiAP_{j}=\bigcup_{i=1}^{k}AP_{i} is the set of propositions, γS×S\gamma\subseteq S\times S is the transition relation, L:S2APjL:S\rightarrow 2^{AP_{j}} is the labeling function, and W:γ0W:\gamma\rightarrow\mathbb{R}_{\geq 0} is the cost function (a function of 𝒲i\mathcal{W}_{i}). More details on the full definition can be found in [25]. See Fig. 1 for an example of a robot model.

Refer to caption
Figure 1: Partial model of robot AblueA_{blue} (see Sec. IV): (a) λ𝑏𝑒𝑒𝑝\lambda_{\mathit{beep}} (b) λ𝑚𝑜𝑡𝑖𝑜𝑛\lambda_{\mathit{motion}} (c) AblueA_{blue}

III-C Task Grammar - LTLψ

We first introduced LTLψin [1]. In this work, because we are removing the assumption of instantaneous behavior, the “next” operator is no longer meaningful therfore we omit it. The task grammar for LTLψincludes atomic propositions that abstract robot action, logical and temporal operators, as in LTL, and bindings that relate actions to specific robots; any action labeled with a certain binding must be satisfied by all the robot(s) assigned that binding.

We define a task φψ\varphi^{\psi} recursively over LTL and binding formulas.

ψ\displaystyle\psi :=ρ|ψ1ψ2|ψ1ψ2\displaystyle:=\rho\>|\>\psi_{1}\vee\psi_{2}\>|\>\psi_{1}\wedge\psi_{2} (1)
φ\displaystyle\varphi :=π|¬φ|φφ|φ𝒰φ\displaystyle:=\pi\ |\ \neg\varphi\ |\ \varphi\vee\varphi\ |\ \varphi\ \mathcal{U}\ \varphi (2)
φψ\displaystyle\varphi^{\psi}\! :=φψ|¬(φψ)|φ1ψ1φ2ψ2|φ1ψ1φ2ψ2|φ1ψ1𝒰φ2ψ2|φψ\displaystyle:=\varphi^{\psi}\!\>|\>\neg(\varphi^{\psi})\>|\>\!\varphi_{1}^{\psi_{1}}\!\!\wedge\!\varphi_{2}^{\psi_{2}}|\ \!\varphi_{1}^{\psi_{1}}\!\!\vee\!\varphi_{2}^{\psi_{2}}\!\>|\>\varphi_{1}^{\psi_{1}}\mathcal{U}\varphi_{2}^{\psi_{2}}\!\>|\>\Box\varphi^{\psi} (3)

where ψ\psi, the binding formula, is a Boolean formula excluding negation over the binding propositions ρAPψ\rho\in AP_{\psi}, and φ\varphi is an LTL formula consisting of the set of propositions APφAP_{\varphi}.

Semantics: The semantics of an LTLψ formula φψ\varphi^{\psi} are defined over the team trace σ=σ1σ2σn\sigma=\sigma_{1}\sigma_{2}...\sigma_{n}, where each σj\sigma_{j} is the trace for robot jj; and the set of binding assignments R={r1,r2,,rn}R=\{r_{1},r_{2},...,r_{n}\}, where rjRr_{j}\in R is the set of bindings in APψAP_{\psi} that are assigned to robot jj. A robot’s binding assignment does not change throughout the task execution (i.e. RR remains the same). For example, r1={2},r2={1,3}r_{1}=\{2\},r_{2}=\{1,3\} indicates that robot 1 is assigned binding 2, and robot 2 is assigned bindings 1 and 3.

Given a set of binding propositions APψAP_{\psi}, ζ:ψ22APψ\zeta:\psi\rightarrow 2^{2^{AP_{\psi}}} outputs all possible combinations of ρAPψ\rho\in AP_{\psi} that satisfy ψ\psi. For example, ζ((12)3)={{1,2},{3},{1,2,3}}\zeta\bigl{(}(1\wedge 2)\vee 3\bigr{)}=\{\{1,2\},\{3\},\{1,2,3\}\}. We say that a team of robots satisfies the formula φψ\varphi^{\psi} if and only if a binding assignment exists in ζ(ψ)\zeta(\psi) such that all the bindings are assigned to (at least one) robot, and the behavior of all robots with these binding assignments satisfy φ\varphi. A robot may be assigned to multiple bindings, and a binding may be assigned to multiple robots.

Formally, the semantics are defined recursively as follows:

  • (σ(i),R)φψ(\sigma(i),R)\!\models\varphi^{\psi} iff Kζ(ψ)\exists K\in\zeta(\psi) s.t. (Kp=1nrpK\subseteq\bigcup\limits_{p=1}^{n}r_{p}) and (j\forall j s.t. KrjK\cap r_{j}\neq\emptyset, σj(i)φ\sigma_{j}(i)\models\varphi)

  • (σ(i),R)(¬φ)ψ(\sigma(i),R)\!\models(\neg\varphi)^{\psi} iff Kζ(ψ)\exists K\in\zeta(\psi) s.t. (Kp=1nrpK\subseteq\bigcup\limits_{p=1}^{n}r_{p}) and (j\forall j s.t. KrjK\cap r_{j}\neq\emptyset, σj(i)⊧̸φ\sigma_{j}(i)\not\models\varphi)

  • (σ(i),R)¬(φψ)(\sigma(i),R)\!\models\neg(\varphi^{\psi}) iff Kζ(ψ)\exists K\in\zeta(\psi) s.t. (Kp=1nrpK\subseteq\bigcup\limits_{p=1}^{n}r_{p}) and (j\exists j s.t. KrjK\cap r_{j}\neq\emptyset, σj(i)⊧̸φ\sigma_{j}(i)\not\models\varphi)

  • (σ(i),R)φ1ψ1φ2ψ2(\sigma(i),\!R)\!\!\models\!\!\varphi_{1}^{\psi_{1}}\!\wedge\varphi_{2}^{\psi_{2}} iff (σ(i),R)φ1ψ1(\sigma(i),\!R)\!\!\models\!\varphi_{1}^{\psi_{1}}and (σ(i),R)φ2ψ2(\sigma(i),\!R)\!\models\!\varphi_{2}^{\psi_{2}}

  • (σ(i),R)φ1ψ1φ2ψ2(\sigma(i),\!R)\!\models\!\varphi_{1}^{\psi_{1}}\!\vee\!\varphi_{2}^{\psi_{2}} iff (σ(i),R)φ1ψ1(\sigma(i),\!R)\!\models\!\varphi_{1}^{\psi_{1}}or (σ(i),R)φ2ψ2(\sigma(i),R)\!\models\varphi_{2}^{\psi_{2}}

  • (σ(i),R)φψ(\sigma(i),R)\models\bigcirc\varphi^{\psi} iff σ(i+1),Rφψ\sigma(i+1),R\models\varphi^{\psi}

  • (σ(i),R)φ1ψ1𝒰φ2ψ2(\sigma(i),R)\!\models\varphi_{1}^{\psi_{1}}\mathcal{U}\varphi_{2}^{\psi_{2}} iff i\exists\ell\geq i s.t. (σ(),R)φ2ψ2(\sigma(\ell),R)\models\varphi_{2}^{\psi_{2}} and ik<,(σ(k),R)φ1ψ1\forall i\leq k<\ell,(\sigma(k),R)\models\varphi_{1}^{\psi_{1}}

  • (σ(i),R)φψ(\sigma(i),R)\models\Box\varphi^{\psi} iff >i,(σ(),R)φψ\forall\ell>i,(\sigma(\ell),R)\models\varphi^{\psi}

Remark 1.

The notation ¬φψ\neg\varphi^{\psi} and (¬φ)ψ(\neg\varphi)^{\psi} are equivalent. For example, ¬roomB1(¬roomB)1\neg roomB^{1}\triangleq(\neg roomB)^{1}.

Remark 2.

There is an important distinction between (¬φ)ψ(\neg\varphi)^{\psi} and ¬(φψ)\neg(\varphi^{\psi}). (¬φ)ψ(\neg\varphi)^{\psi} requires that the traces of all robots with binding assignments that satisfy ψ\psi, satisfy ¬φ\neg\varphi. ¬(φψ)\neg(\varphi^{\psi}) requires the formula φψ\varphi^{\psi} to be violated; at least one robot’s trace with a binding assignment that satisfies ψ\psi does not satisfy φ\varphi (equivalently, satisfies ¬φ\neg\varphi).

Remark 3.

Unique to LTLψ is the ability to encode constraints either on all robots or on at least one robot. φψ\varphi^{\psi} captures “all robots assigned a binding in Kζ(ψ)K\in\zeta(\psi) must satisfy φ\varphi”; ¬(¬φψ)\neg(\neg\varphi^{\psi}) captures “at least one robot assigned a binding in Kζ(ψ)K\in\zeta(\psi) satisfies φ\varphi”. This allows the same binding to be assigned to multiple robots, but only one of those robots needs to satisfy φ\varphi. This can be especially valuable when encoding safety requirements; for example, the formula ¬(¬roomB1)(roomBcamera)2\neg(\neg roomB^{1})\Rightarrow(roomB\wedge camera)^{2} captures “if any robot assigned binding 1 is in room B, all robots assigned binding 2 must take a picture of the room.”

Example: Task 1

Refer to caption
Figure 2: Büchi automaton for Task 1
φψ=(dockc1)(¬(¬dockc1)(roomBccamera)23)\displaystyle\varphi^{\psi}=\Diamond(dock_{c}^{1})\wedge\Box(\neg(\neg dock_{c}^{1})\rightarrow(roomB_{c}\wedge camera)^{2\wedge 3}) (4)

In English, the specification captures “All robot(s) assigned binding 1 must eventually be at the dock. Anytime one of these robots is at the dock, all robot(s) assigned bindings 2 and 3 must be in room B taking pictures.” The second part of the task is a safety constraint that ensures that the dock is monitored anytime a robot assigned binding 1 is in that room.

IV Problem Statement

Given nn heterogeneous robots A={A1,,An}A=\{A_{1},...,A_{n}\} and a task φψ\varphi^{\psi} in LTLψ, find a team of robots A^A\hat{A}\subseteq A, their binding assignments RA^R_{\hat{A}}, and synthesize behavior σj\sigma_{j} for each robot such that (σ(0),RA^)φψ(\sigma(0),R_{\hat{A}})\models\varphi^{\psi} and can by design be implemented in continuous execution (i.e., the physical execution of σj\sigma_{j} does not violate any part of φ\varphi). Similar to our prior work, this behavior includes synchronization constraints implicitly encoded in the task for robots to satisfy the necessary collaborative actions.

We assume that the system is nonreactive; robots cannot change their behavior at runtime. We also assume that every state in both the Büchi automaton of the task φψ\varphi^{\psi} and the robot model has a self-transition (i.e. the robot can wait in any state).

Example: Let there be four robots A={AgreenA=\{A_{green}, AblueA_{blue}, AorangeA_{orange}, Apink}A_{pink}\} in a warehouse environment (Fig. 3). The set of all capabilities is Λ={λmot,λarm,λbeep,λcam,λscan}\Lambda=\{\lambda_{mot},\lambda_{arm},\lambda_{beep},\lambda_{cam},\lambda_{scan}\}, where λmot\lambda_{mot} is the motion model representing how the robots can move through the environment. λarm\lambda_{arm} represents a robotic manipulator; the arm can pick up and drop off packages, as well as push boxes. λbeep\lambda_{beep}, λcam\lambda_{cam}, and λscan\lambda_{scan} are a robot’s ability to beep, take a picture, and scan, respectively. λmot\lambda_{mot} and λarm\lambda_{arm} execute non-instantaneous actions; the remaining capabilities contain only instantaneous actions.

The robots’ capabilities and labels on their initial states are:

Λgreen={λ𝑚𝑜𝑡,λarm,λcamera},L(s0)={roomDc}\Lambda_{green}=\{\lambda_{\mathit{mot}},\lambda_{arm},\lambda_{camera}\},L(s_{0})=\{roomD_{c}\}
Λblue={λ𝑚𝑜𝑡,λbeep},L(s0)={roomCc}\Lambda_{blue}=\{\lambda_{\mathit{mot}},\lambda_{beep}\},L(s_{0})=\{roomC_{c}\}
Λorange={λ𝑚𝑜𝑡,λarm},L(s0)={roomEc}\Lambda_{orange}=\{\lambda_{\mathit{mot}},\lambda_{arm}\},L(s_{0})=\{roomE_{c}\}
Λpink={λ𝑚𝑜𝑡,λbeep,λcam,λscan}\Lambda_{pink}=\{\lambda_{\mathit{mot}},\lambda_{beep},\lambda_{cam},\lambda_{scan}\}, L(s0)={roomEc}L(s_{0})=\{roomE_{c}\}

The goal is to construct a team, i.e. a subset of these robots, and corresponding binding assignments for the robots to satisfy the task captured as the LTLψspecification provided in Eq. 4. We assume that the robots have low-level controllers that ensure collision avoidance and coordination when multiple robots execute a capability together (e.g. pushing a cart).

Refer to caption
Figure 3: Environment and robot setup

V Approach

To find a teaming assignment and synthesize the corresponding synchronization and control that is guaranteed to satisfy the task even when actions have varying execution times, we start with an approach similar to our prior work [1]: first, we automatically generate a Büchi automaton \mathcal{B} for the task φψ\varphi^{\psi} (Sec. V-A). Each robot AjA_{j} then constructs a product automaton 𝒢j=Aj×\mathcal{G}_{j}=A_{j}\times\mathcal{B} (Sec. V-B). The novelty in our current work is our approach to finding a team of robots to satisfy the task. In prior work, we used a depth first search (DFS) algorithm to find both a team of robots and a trace through \mathcal{B} to an accepting cycle. For every transition in the trace, every proposition in APψAP_{\psi} is assigned to at least one robot in the team. In this paper, we further ensure that the varying time durations of the actions do not result in violations of any part of the task. To do so, we update the Büchi automaton as the DFS progresses to include intermediate states that enforce the necessary ordering of actions without violating the original specification (Sec. V-C). As a result, we also update a robot’s product automaton to reflect the changes in the Büchi automaton (Sec. V-D). The entire DFS framework is outlined in Sec. V-E.

Once an accepting trace and corresponding robot team is found, each robot synthesizes its own behavior that allows for parallel execution. However, some parts of the task may require collaboration, in which case the robots must synchronize. We create a synchronization policy where each robot communicates to others when they need to synchronize and waits for other robots before executing the collaborative portions of their behavior (Sec. V-F).

V-A Büchi Automaton for an LTLψ Formula

To create a Büchi automaton from an LTLψ specification, we first modify the specification to constrain binding propositions solely to individual atomic propositions πAPφ\pi\in AP_{\varphi} (i.e. the formula contains only πρ\pi^{\rho}). For example, the formula ((pickuproomAc))12(\Diamond(pickup\wedge roomA_{c}))^{1\vee 2} is rewritten as ((pickup1roomAc1)((pickup2roomAc2))(\Diamond(pickup^{1}\wedge roomA_{c}^{1})\vee(\Diamond(pickup^{2}\wedge roomA_{c}^{2})).

Using APφAP_{\varphi} and APψAP_{\psi}, we define APφψAP_{\varphi}^{\psi}, where πAPφ\forall\pi\in AP_{\varphi} and ρAPψ\forall\rho\in AP_{\psi}, πρAPφψ\pi^{\rho}\in AP_{\varphi}^{\psi}. We automatically create the Büchi automaton from these propositions using Spot [26].

Prior to control synthesis, we first convert the transitions in the Büchi automaton, labeled with Boolean formulas, into disjunctive normal form (DNF). Subsequently, we substitute the transition labeled with a DNF formula containing \ell conjunctive clauses with \ell transitions between the same states. The label for each of these transitions is a distinct conjunction of the original label.

When constructing a Büchi automaton from an LTL formula φ\varphi, σΣ\sigma\in\Sigma_{\mathcal{B}} are Boolean formulas over APφAP_{\varphi}, the atomic propositions that appear in φ\varphi. In this work, for a Büchi automaton of an LTLψ formula, Σ=2APφψ×2APφψ×2APφψ×2APφψ\Sigma_{\mathcal{B}}=2^{AP_{\varphi}^{\psi}}\times 2^{AP_{\varphi}^{\psi}}\times 2^{AP_{\varphi}^{\psi}}\times 2^{AP_{\varphi}^{\psi}}, where σ=(σT,σexT,σF,σexF)Σ\sigma=(\sigma^{T},\sigma^{exT},\sigma^{F},\sigma^{exF})\in\Sigma_{\mathcal{B}} contains the set of propositions πρ\pi^{\rho} that must be true/false for all robots (σT\sigma^{T} and σF\sigma^{F}), called for all propositions, and the set of propositions πρ\pi^{\rho} that must be true/false for at least one robot (σexT\sigma^{exT} and σexF\sigma^{exF}), called there exists propositions. σexT\sigma^{exT} are the set of propositions in which ¬(¬πρ)\neg(\neg\pi^{\rho}) is true; σexF\sigma^{exF} are the set of propositions in which ¬(πρ)\neg(\pi^{\rho}) is true. Any proposition that does not appear in σ\sigma can maintain any truth value.

We modify the definition of σ\sigma compared to our prior work [1], where we assumed instantaneous robot actions; there, σ=(σT,σF)\sigma=(\sigma_{T},\sigma_{F}). While [1] also had there exists propositions, in practice the resulting behavior of there exists and for all propositions was the same. This is because, for a there exists proposition πρ\pi^{\rho}, only one robot assigned binding ρ\rho needs to execute πρ\pi^{\rho}. However, since the robots do not coordinate, if there are multiple robots assigned ρ\rho, they all satisfy πρ\pi^{\rho} (satisfying for all propositions also satisfies there exists propositions). Thus, it was unnecessary in [1] to differentiate between these two types of propositions. This is not true for time varying actions; there are scenarios in which a there exists proposition is satisfied but a for all proposition is not.

Example. Consider the task defined in Eq. 4. Supposed we have two robots with rgreen={1},rblue={2,3}r_{green}=\{1\},r_{blue}=\{2,3\}. Our prior approach may output a discrete teaming plan in which the blue robot enters the dock at exactly the same time the green robot enters room B. However, the physical execution of this plan may violate the specification; although the robots can begin moving towards their respective areas at the same time, the green robot may enter the dock before the blue robot enters room B, thus violating the safety constraint.

V-B Constructing the Product Automaton

To formally define the product automaton, we first modify the functions introduced in [1]. For illustration, we will use the Büchi automaton for task 1 as our example (Fig. 2). Let the outer self-transition on state 1 be σ11,o\sigma_{11,o}. σ11,o=(σ11,oT,σ11,oexT,σ11,oF,σ11,oexF)=({roomBc2,camera2,roomBc3,camera3},,,{dockc1})\sigma_{11,o}=(\sigma_{11,o}^{T},\sigma^{exT}_{11,o},\sigma_{11,o}^{F},\sigma^{exF}_{11,o})=(\{roomB_{c}^{2},camera^{2},roomB_{c}^{3},camera^{3}\},\emptyset,\emptyset,\{dock_{c}^{1}\}).

Definition 1 (Binding Transition Function).

𝔅σ:Σ2APψ\mathfrak{B}_{\sigma}:\Sigma_{\mathcal{B}}\rightarrow 2^{AP_{\psi}} such that for σ=(σT,σexT,σF,σexF)Σ,𝔅σ(σ)APψ\sigma{=(\sigma^{T},\sigma^{exT},\sigma^{F},\sigma^{exF})}\in\Sigma_{\mathcal{B}},\mathfrak{B}_{\sigma}(\sigma)\subseteq AP_{\psi} is the set {ρAPψ|πρσTσexTσFσexF}\{\rho\in AP_{\psi}\ |\ \exists\pi^{\rho}\in{\sigma^{T}\cup\sigma^{exT}\cup\sigma^{F}\cup\sigma^{exF}\}}.

𝔅σ(σ)\mathfrak{B}_{\sigma}(\sigma) outputs the set of bindings that appear in a Büchi transition label σ\sigma. For example, 𝔅σ(σ11,o)={1,2,3}\mathfrak{B}_{\sigma}(\sigma_{11,o})=\{1,2,3\}.

Definition 2 (Binding Set Function).

𝔅Π:2APφψ2APψ\mathfrak{B}_{\Pi}:2^{AP_{\varphi}^{\psi}}\rightarrow 2^{AP_{\psi}} such that for ΠAPφψ,𝔅Π(Π)APψ\Pi\subseteq AP_{\varphi}^{\psi},\mathfrak{B}_{\Pi}(\Pi)\subseteq AP_{\psi} is the set {ρAPψ|πρΠ}\{\rho\in AP_{\psi}\ |\ \exists\pi^{\rho}\in{\Pi\}}.

𝔅Π(Π)\mathfrak{B}_{\Pi}(\Pi) outputs the set of bindings in a given set of LTLψ propositions Π\Pi. For example, for Π={roomBc2,camera2,roomBc3,camera3,dockc1}\Pi=\{roomB_{c}^{2},camera^{2},roomB_{c}^{3},camera^{3},dock_{c}^{1}\}, 𝔅Π(Π)={1,2,3}\mathfrak{B}_{\Pi}(\Pi)=\{1,2,3\}; for Π={dockc1}\Pi=\{dock_{c}^{1}\}, 𝔅Π(Π)={1}\mathfrak{B}_{\Pi}(\Pi)=\{1\}.

Definition 3 (Capability Function).

:Σ×APψ2APφ×2APφ×2APφ×2APφ\mathfrak{C}:\Sigma_{\mathcal{B}}\times AP_{\psi}\rightarrow 2^{AP_{\varphi}}\times 2^{AP_{\varphi}}\times 2^{AP_{\varphi}}\times 2^{AP_{\varphi}} such that for (σT,σexT,σF,σexF)Σ,ρAPψ(\sigma^{T},\sigma^{exT},\sigma^{F},\sigma^{exF})\in\Sigma_{\mathcal{B}},\rho\in AP_{\psi}, (σ,ρ)=(CT,CexT,CF,CexF)\mathfrak{C}(\sigma,\rho)=(C_{T},C_{exT},C_{F},C_{exF}), where for k{T,exT,F,exF}k\in\{T,exT,F,exF\}, Ck={πAPφ|πρσk}C_{k}=\{\pi\in AP_{\varphi}\ |\ \exists\pi^{\rho}\in\sigma^{k}\}.

CTC_{T} and CFC_{F} are the sets of for all propositions that are True/False and appear with binding ρ\rho in label σ\sigma of a Büchi transition and must be True/False for all robots assigned binding ρ\rho; CexTC_{exT} and CexFC_{exF} are defined similarly but for there exists propositions with binding ρ\rho. For example, for σ11,o=({roomBc2,camera2,roomBc3,camera3},,,{dockc1})\sigma_{11,o}=(\{roomB_{c}^{2},camera^{2},roomB_{c}^{3},camera^{3}\},\emptyset,\emptyset,\{dock_{c}^{1}\}), (σ11,o,2)=({roomBc,camera},,,)\mathfrak{C}(\sigma_{11,o},2)=(\{roomB_{c},camera\},\emptyset,\emptyset,\emptyset) (for binding 2, the relevant propositions are roomBcroomB_{c} and cameracamera, both of which must be true and are for all propositions, i.e. the set σT\sigma^{T}), and (σ11,o,1)=(,,,{dockc})\mathfrak{C}(\sigma_{11,o},1)=(\emptyset,\emptyset,\emptyset,\{dock_{c}\}) (dockcdock_{c} is the only proposition with the binding 1 and is in σexF\sigma^{exF}).

Definition 4 (Binding Assignment Function).

Given a robot model AjA_{j} and a label σ=(σT,σexT,σF,σexF)\sigma=(\sigma^{T},\sigma^{exT},\sigma^{F},\sigma^{exF}), (s,σ,s)={r2APψ|ρr,(CT,CexT,CF,CexF)=(σ,ρ),ρr(CTCexT)L(s)\mathfrak{R}(s,\sigma,s^{\prime})=\{r\in 2^{AP_{\psi}}\setminus\emptyset\ |\ \forall\rho\in r,(C_{T},C_{exT},C_{F},C_{exF})=\mathfrak{C}(\sigma,\rho),\bigcup_{\rho\in r}(C_{T}\cup C_{exT})\subseteq L(s^{\prime}) and ρr(CFCexF)L(s)=}\bigcup_{\rho\in r}(C_{F}\cup C_{exF})\cap L(s^{\prime})=\emptyset\}.

To synthesize behavior for a robot, we find the minimum cost accepting trace in its product automaton 𝒢j=Aj×\mathcal{G}_{j}=A_{j}\times\mathcal{B}, where Aj=(S,s0,APj,γ,L,W)A_{j}=(S,s_{0},AP_{j},\gamma,L,W) is the robot model, and =(Z,z0,Σ,δ,F)\mathcal{B}=(Z,z_{0},\Sigma_{\mathcal{B}},\delta_{\mathcal{B}},F) is the Büchi automaton.

Given a transition (s,σ,s)(s,\sigma,s^{\prime}), \mathfrak{R} generates all possible combinations of binding propositions that can be assigned to a robot to satisfy σ\sigma. A robot can be assigned binding ρ\rho if and only if two conditions hold on the robot’s next state, ss^{\prime}: 1) the state label of ss^{\prime} contains all propositions π\pi that appear in either σT\sigma^{T} or σexT\sigma^{exT} as πρ\pi^{\rho}, and 2) the state label of ss^{\prime} does not contain any propositions π\pi that appear in σF\sigma^{F} or σexF\sigma^{exF} as πρ\pi^{\rho}.

A binding assignment rr can contain any binding propositions not in σ\sigma, since there are no propositions required by those bindings. In addition, it follows from condition (2) that if a proposition πρ\pi^{\rho} is in σFσexF\sigma^{F}\cup\sigma^{exF} and π\pi is not in APjAP_{j} (e.g. camera1σFcamera^{1}\in\sigma^{F} and the robot does not have the capability λcamera\lambda_{camera}), ρ\rho can still be assigned to robot jj.

Given the binding assignment function \mathfrak{R}, and as shown in [1], we can now define the product automaton:

Definition 5 (Product Automaton).

𝒢j=Aj×=(Q,q0,APj,δ𝒢,L𝒢,W𝒢,F𝒢)\mathcal{G}_{j}=A_{j}\times\mathcal{B}=(Q,q_{0},AP_{j},\delta_{\mathcal{G}},L_{\mathcal{G}},W_{\mathcal{G}},F_{\mathcal{G}}), where

  • Q=S×ZQ=S\times Z is a finite set of states

  • q0=(s0,z0)Qq_{0}=(s_{0},z_{0})\in Q is the initial state

  • δ𝒢Q×Q\delta_{\mathcal{G}}\subseteq Q\times Q is the transition relation, where for q=(s,z)q=(s,z) and q=(s,z)q^{\prime}=(s^{\prime},z^{\prime}), (q,q)δ𝒢(q,q^{\prime})\in\delta_{\mathcal{G}} if and only if (s,s)γ(s,s^{\prime})\in\gamma and σΣ\exists\sigma\in\Sigma_{\mathcal{B}} such that (z,σ,z)δ(z,\sigma,z^{\prime})\in\delta_{\mathcal{B}} and (s,σ,s)\mathfrak{R}(s,\sigma,s^{\prime})\neq\emptyset

  • L𝒢L_{\mathcal{G}} is the labeling function s.t. for q=(s,z)q=(s,z), L𝒢(q)=L(s)APjL_{\mathcal{G}}(q)\!=\!L(s)\!\subseteq\!AP_{j}

  • W𝒢:δ𝒢0W_{\mathcal{G}}:\delta_{\mathcal{G}}\rightarrow\mathbb{R}_{\geq 0} is the cost function s.t. for (q,q)δ𝒢(q,q^{\prime})\in\delta_{\mathcal{G}}, q=(s,z)q=(s,z), q=(s,z)q^{\prime}=(s^{\prime},z^{\prime}), W𝒢((q,q))=W((s,s))W_{\mathcal{G}}((q,q^{\prime}))=W((s,s^{\prime}))

  • F𝒢=S×FF_{\mathcal{G}}=S\times F is the set of accepting states

V-C Adding Intermediate Transitions to the Büchi Automaton

To ensure correct team behavior when actions take different time durations, we add intermediate transitions to the Büchi automaton \mathcal{B} to reason about and enforce an ordering on individual robot behaviors (Alg. 1). In doing so, we maintain the symbolic abstractions of actions while providing guarantees for the satisfaction of the task by a physical system.

To motivate the use of intermediate transitions, we look at the transitions σ11,i\sigma_{11,i} (the inner self-transition along state 1) and σ10\sigma_{10} of the Büchi automaton in Fig 2, where σ11,i=(σ11,iT,σ11,iexT,σ11,iF,σ11,iexF)=(,,{dockc1},)\sigma_{11,i}=(\sigma_{11,i}^{T},\sigma^{exT}_{11,i},\sigma_{11,i}^{F},\sigma^{exF}_{11,i})=(\emptyset,\emptyset,\{dock_{c}^{1}\},\emptyset), σ10=(σ10T,σ10exT,σ10F,σ10exF)=({roomBc2,camera2,roomBc3,camera3,dockc1},,,)\sigma_{10}=(\sigma_{10}^{T},\sigma^{exT}_{10},\sigma_{10}^{F},\sigma^{exF}_{10})=(\{roomB_{c}^{2},camera^{2},roomB_{c}^{3},camera^{3},dock_{c}^{1}\},\emptyset,\emptyset,\emptyset). σ10\sigma_{10} requires all robots assigned binding 2 and 3 to be in roomB. Since it is unrealistic for multiple robots to enter the room simultaneously, we can leverage the fact that σ11,i\sigma_{11,i} does not explicitly assign truth values to roomBc2roomB_{c}^{2} and roomBc3roomB_{c}^{3} (i.e. these propositions can have any truth value over σ11,i\sigma_{11,i}) in order to enforce that all the robots assigned bindings 2 and 3 enter room B at some point before executing the transition σ10\sigma_{10}. For clarity in the remainder of the paper, we define a proposition πρ\pi^{\rho} to be assigned an explicit truth value over a transition σ\sigma if it appears in σ\sigma, i.e. πρσTσexTσFσexF\pi^{\rho}\in\sigma^{T}\cup\sigma^{exT}\cup\sigma^{F}\cup\sigma^{exF}. If a proposition is not explicitly in σ\sigma, it can maintain any truth value over that transition.

To automatically construct intermediate transitions, we first define the intermediate propositions function, (σ)\mathcal{I}(\sigma):

Definition 6 (Intermediate Propositions Function).

(σ):Σ2APnoninst×2APnoninst×2APnoninst×2APnoninst\mathcal{I}(\sigma):\Sigma_{\mathcal{B}}\rightarrow 2^{AP_{non-inst}}\times 2^{AP_{non-inst}}\times 2^{AP_{non-inst}}\times 2^{AP_{non-inst}} such that for σ=(σT,σexT,σF,σexF)Σ\sigma=(\sigma^{T},\sigma^{exT},\sigma^{F},\sigma^{exF})\in\Sigma_{\mathcal{B}}, (σ)=(IT,IexT,IF,IexF)\mathcal{I}(\sigma)=(I_{T},I_{exT},I_{F},I_{exF}), where k{T,exT,F,exF},Ik={πρσk|APnoninst(Ck(σ,ρ))}\forall k\in\{T,exT,F,exF\},I_{k}=\{\pi^{\rho}\in\sigma^{k}\ |AP_{non-inst}\cap(C_{k}\in\mathfrak{C}(\sigma,\rho))\neq\emptyset\}

ITI_{T}, IexTI_{exT}, IFI_{F}, and IexFI_{exF} are the sets of LTLψ propositions corresponding to non-instantaneous actions that are assigned truth values over σT,σexT,σF, and σexF\sigma^{T},\sigma^{exT},\sigma^{F},\text{ and }\sigma^{exF}, respectively. For example, in Fig. 2 where σ11,o=(σ11,oT,σ11,oexT,σ11,oF,σ11,oexF)=({roomBc2,camera2,roomBc3,camera3},,,{dockc1})\sigma_{11,o}=(\sigma_{11,o}^{T},\sigma^{exT}_{11,o},\sigma_{11,o}^{F},\sigma^{exF}_{11,o})=(\{roomB_{c}^{2},camera^{2},roomB_{c}^{3},camera^{3}\},\emptyset,\emptyset,\{dock_{c}^{1}\}), the intermediate propositions are (σ11,o)=({roomBc2,roomBc3},,,{dockc1})\mathcal{I}(\sigma_{11,o})=(\{roomB_{c}^{2},roomB_{c}^{3}\},\emptyset,\emptyset,\{dock_{c}^{1}\}), since all the motion propositions are non-instantaneous; cameracamera is instantaneous and therefore omitted from (σ11,o)\mathcal{I}(\sigma_{11,o}).

We use the intermediate propositions function to determine which non-instantaneous propositions change truth values across two transitions; we then use these propositions to enforce constraints on the binding assignments and on robot behavior. Let σ,σ\sigma,\sigma^{\prime} be labels of two transitions in the Büchi automaton, and (σ)=(IT,IexT,IF,IexF),(σ)=(IT,IexT,IF,IexF)\mathcal{I}(\sigma)=(I_{T},I_{exT},I_{F},I_{exF}),\mathcal{I}(\sigma^{\prime})=(I^{\prime}_{T},I^{\prime}_{exT},I^{\prime}_{F},I^{\prime}_{exF}). To categorize how these propositions change their truth values, we define the following sets (Alg. 1, line 1):

ΠT\displaystyle\Pi_{T} =IT(IFIexF)\displaystyle=I_{T}\cap(I^{\prime}_{F}\cup I^{\prime}_{exF}) (5)
ΠF\displaystyle\Pi_{F} =IF(ITIexT)\displaystyle=I_{F}\cap(I^{\prime}_{T}\cup I^{\prime}_{exT}) (6)

ΠT,ΠFAPnoninst\Pi_{T},\Pi_{F}\subseteq AP_{non-inst} are the sets of non-instantaneous for all propositions that explicitly change truth values between σ\sigma and σ\sigma^{\prime}.

ΠexT\displaystyle\Pi_{exT} =IexT(IFIexF)\displaystyle=I_{exT}\cap(I^{\prime}_{F}\cup I^{\prime}_{exF}) (7)
ΠexF\displaystyle\Pi_{exF} =IexF(ITIexT)\displaystyle=I_{exF}\cap(I^{\prime}_{T}\cup I^{\prime}_{exT}) (8)

ΠexT,ΠexFAPnoninst\Pi_{exT},\Pi_{exF}\subseteq AP_{non-inst} include any non-instantaneous proposition that is a there exists proposition in σ\sigma that explicitly changes truth values between σ\sigma and σ\sigma^{\prime}.

ΠT\displaystyle\Pi_{\emptyset T} =(ITIT)\displaystyle=(I^{\prime}_{T}\setminus I_{T}) (9)
ΠexT\displaystyle\Pi_{\emptyset exT} =(IexTIexT)\displaystyle=(I^{\prime}_{exT}\setminus I_{exT}) (10)
ΠF\displaystyle\Pi_{\emptyset F} =(IFIF)\displaystyle=(I^{\prime}_{F}\ \setminus I_{F}) (11)
ΠexF\displaystyle\Pi_{\emptyset exF} =(IexFIexF)\displaystyle=(I^{\prime}_{exF}\setminus I_{exF}) (12)

ΠT,ΠexT,ΠF,ΠexFAPnoninst\Pi_{\emptyset T},\Pi_{\emptyset exT},\Pi_{\emptyset F},\Pi_{\emptyset exF}\subseteq AP_{non-inst} are the sets of non-instantaneous propositions that are assigned truth values in σ\sigma^{\prime} but not in σ\sigma.

Example: Task 1. In Fig. 2, consider the two transitions (1,σ11,i,1)(1,\sigma_{11,i},1), (1,σ10,0)(1,\sigma_{10},0), where σ11,i=(,,{dockc1},)\sigma_{11,i}=(\emptyset,\emptyset,\{dock_{c}^{1}\},\emptyset) is the inner self-transition on state 1, and σ10=({roomBc2,camera2,roomBc3,camera3,dockc1},,,)\sigma_{10}=(\{roomB_{c}^{2},camera^{2},roomB_{c}^{3},camera^{3},dock_{c}^{1}\},\emptyset,\emptyset,\emptyset). Then ΠF={dockc1}\Pi_{F}=\{dock_{c}^{1}\}, ΠT={roomBc2,roomBc3}\Pi_{\emptyset T}=\{roomB_{c}^{2},roomB_{c}^{3}\}; the remaining sets are empty.

Input : ,e1=(z1,σ12,z2),e2=(z2,σ23,z3)\mathcal{B},e_{1}=(z_{1},\sigma_{12},z_{2}),e_{2}=(z_{2},\sigma_{23},z_{3}) , where σ12=(σ12T,σ12exT,σ12F,σ12exF)\sigma_{12}=(\sigma_{12}^{T},\sigma_{12}^{exT},\sigma_{12}^{F},\sigma_{12}^{exF}), σ23=(σ23T,σ23exT,σ23F,σ23exF)\sigma_{23}=(\sigma_{23}^{T},\sigma_{23}^{exT},\sigma_{23}^{F},\sigma_{23}^{exF})
Output : upd,Eupd,(csingle,ccombo)\mathcal{B}_{upd},E_{upd},(c_{single},c_{combo})
1
2upd=\mathcal{B}_{upd}=\mathcal{B}, csingle=,ccombo=c_{single}=\emptyset,c_{combo}=\emptyset
3 (IT,IexT,IF,IexF)=(σ12),(IT,IexT,IF,IexF)=(σ23)(I_{T},I_{exT},I_{F},I_{exF})=\mathcal{I}(\sigma_{12}),(I^{\prime}_{T},I^{\prime}_{exT},I^{\prime}_{F},I^{\prime}_{exF})=\mathcal{I}(\sigma_{23})
// compute sets of non-inst actions
4 ΠT,ΠF,ΠexT,ΠexF,ΠT,ΠF,ΠexT,ΠexF=non_inst_sets((IT,IexT,IF,IexF),(IT,IexT,IF,IexF))\Pi_{T},\Pi_{F},\Pi_{exT},\Pi_{exF},\Pi_{\emptyset T},\Pi_{\emptyset F},\Pi_{\emptyset exT},\Pi_{\emptyset exF}=\textsc{non\_inst\_sets}((I_{T},I_{exT},I_{F},I_{exF}),(I^{\prime}_{T},I^{\prime}_{exT},I^{\prime}_{F},I^{\prime}_{exF}))
// keep track of binding constraints
5 if |ΠTΠF|1|\Pi_{T}\cup\Pi_{F}|\geq 1  then
6       csingle=𝔅Π(ΠTΠF)c_{single}=\mathfrak{B}_{\Pi}(\Pi_{T}\cup\Pi_{F})
7if |ΠexTΠexF|2|\Pi_{exT}\cup\Pi_{exF}|\geq 2 then
8       ccombo=𝔅Π(ΠexTΠexF)c_{combo}=\mathfrak{B}_{\Pi}(\Pi_{exT}\cup\Pi_{exF})
// no need to update Büchi
9 if |ITIexTIFIexF|1|I_{T}^{\prime}\cup I_{exT}^{\prime}\cup I_{F}^{\prime}\cup I_{exF}^{\prime}|\leq 1 or |ΠTΠFΠexTΠexF|<1|\Pi_{T}\cup\Pi_{F}\cup\Pi_{exT}\cup\Pi_{exF}|<1  then
10       return ,,csingle,ccombo\mathcal{B},\emptyset,c_{single},c_{combo}
11σ11=(σ11T,σ11exT,σ11F,σ11exF)=intermediate_trans(σ12,ΠT,ΠexT,ΠF,ΠexF)\sigma_{11^{*}}=(\sigma_{11^{*}}^{T},\sigma_{11^{*}}^{exT},\sigma_{11^{*}}^{F},\sigma_{11^{*}}^{exF})=\textsc{intermediate\_trans}(\sigma_{12},\Pi_{\emptyset T},\Pi_{\emptyset exT},\Pi_{\emptyset F},\Pi_{\emptyset exF}) if z1=z2z_{1}=z_{2}  then
12       add (z1,σ12,z1)(z_{1},\sigma_{12},z_{1^{*}}), (z1,σ11,z1)(z_{1^{*}},\sigma_{11^{*}},z_{1^{*}}), (z1,σ23,z3)(z_{1^{*}},\sigma_{23},z_{3}) to upd\mathcal{B}_{upd}; remove (z2,σ23,z3)(z_{2},\sigma_{23},z_{3}) from upd\mathcal{B}_{upd}
13       Eupd=((z1,σ12,z1)E_{upd}=((z_{1},\sigma_{12},z_{1^{*}}), (z1,σ11,z1)(z_{1^{*}},\sigma_{11^{*}},z_{1^{*}}), (z1,σ23,z3))(z_{1^{*}},\sigma_{23},z_{3}))
14 else
       // modify first transition (non-self transition)
15      
16      if σ12σ11\sigma_{12}\neq\sigma_{11^{*}} then
17             modify (z1,σ12,z2)=(z1,σ11,z2)(z_{1},\sigma_{12},z_{2})=(z_{1},\sigma_{11^{*}},z_{2}) in upd\mathcal{B}_{upd}
18             Eupd=((z1,σ11,z2))E_{upd}=((z_{1},\sigma_{11^{*}},z_{2}))
19      else
20            Eupd=()E_{upd}=()
return upd,Eupd,(csingle,ccombo)\mathcal{B}_{upd},E_{upd},(c_{single},c_{combo})
Algorithm 1 Update Büchi Automaton

Violations of the task may occur when the robots execute a transition in the Büchi automaton \mathcal{B}. Thus, to prevent any violations, we check two sequential transitions in \mathcal{B}, e1=(z1,σ12,z2),e2=(z2,σ23,z3)e_{1}=(z_{1},\sigma_{12},z_{2}),e_{2}=(z_{2},\sigma_{23},z_{3}), and update the Büchi automaton \mathcal{B} if a specific ordering of propositions is necessary. When there is at least one non-instantaneous proposition that changes truth values along e2e_{2}, we want to enforce an ordering such that the other non-instantaneous propositions are completed first. Thus, we only need to modify the Büchi automaton if there exists more than one non-instantaneous proposition appears along e2e_{2} (|ITIexTIFIexF|>1|I_{T}^{\prime}\cup I_{exT}^{\prime}\cup I_{F}^{\prime}\cup I_{exF}^{\prime}|>1) and at least one of them explicitly changes truth values (|ΠTΠexTΠFΠexF|1|\Pi_{T}\cup\Pi_{exT}\cup\Pi_{F}\cup\Pi_{exF}|\geq 1, line 1).

Binding Constraints (lines 1 - 1): There may be a sequence of transitions in which non-instantaneous propositions change truth values, which may require imposing constraints of the robot binding assignments. For example, looking at the same two transitions as before, (1,σ11,i,1)(1,\sigma_{11,i},1) and (1,σ10,0)(1,\sigma_{10},0), ΠTΠF={dockc1}\Pi_{T}\cup\Pi_{F}=\{dock_{c}^{1}\}. In σ11,i\sigma_{11,i}, we require all robots assigned binding 1 to not be in the dock, and in the next transition σ10\sigma_{10}, we require all robots assigned binding 1 to be in the dock. If multiple robots are assigned binding 1, this realistically will not happen when executing in continuous time, as it would require all robots to enter the dock at the exact same time. Thus, to guarantee these transitions in the Büchi automaton are satisfied, we constrain the binding assignments such that one and only one robot can be assigned bindings in 𝔅(ΠTΠF)\mathfrak{B}(\Pi_{T}\cup\Pi_{F}) (in this case, binding 1). The same constraints apply if multiple bindings are present (e.g. if ΠTΠF={dockc1,roomBc2}\Pi_{T}\cup\Pi_{F}=\{dock_{c}^{1},roomB_{c}^{2}\}, then one and only one robot can be assigned both bindings 1 and 2; otherwise, two robots must make the transition at the exact same time, which is not realistic). These combinations of bindings are stored in csinglec_{single}.

Similar constraints apply when |ΠexTΠexF|2|\Pi_{exT}\cup\Pi_{exF}|\geq 2, i.e. multiple there exists propositions change truth values. In this case, for each proposition πρ\pi^{\rho} in ΠexTΠexF\Pi_{exT}\cup\Pi_{exF}, we require that at least one robot assigned ρ\rho will change its truth value of πc\pi_{c} across the two transitions. For instance, if σ12={,,,{dockc1,pushc2}}\sigma_{12}=\{\emptyset,\emptyset,\emptyset,\{dock_{c}^{1},push_{c}^{2}\}\}, σ23={{dockc1,pushc2},,,}\sigma_{23}=\{\{dock_{c}^{1},push_{c}^{2}\},\emptyset,\emptyset,\emptyset\}), σ12\sigma_{12} requires at least one robot assigned binding 1 to not be at the dock, and at least one robot assigned binding 2 to not complete the pushing action, while σ23\sigma_{23} requires all robots assigned binding 1 and 2 to be at the dock and complete pushing, respectively. On a physical system, it is unrealistic for robots to be able to synchronize completing a non-instantaneous action at the same time. As a result, to guarantee satisfiability, we constrain the binding assignment such that if a robot is assigned to any binding in 𝔅Π(ΠexTΠexF)\mathfrak{B}_{\Pi}(\Pi_{exT}\cup\Pi_{exF}), then it must be assigned to all bindings within that set; otherwise, it cannot be assigned to any of them. These binding assignments are stored in ccomboc_{combo}. Note that the constraints are not necessary when |ΠexTΠexF|=1|\Pi_{exT}\cup\Pi_{exF}|=1; in this case, only one robot assigned ρ\rho must change its truth value across the two transitions, which can easily be satisfied by a physical system.

If more than one non-instantaneous proposition appears along the second transition e2e_{2}, we generate an intermediate transition σ11=(σ11T,σ11exT,σ11F,σ11exF)\sigma_{11^{*}}=(\sigma_{11^{*}}^{T},\sigma_{11^{*}}^{exT},\sigma_{11^{*}}^{F},\sigma_{11^{*}}^{exF}) (line 1), where σ11T=σ12TΠT\sigma_{11^{*}}^{T}=\sigma_{12}^{T}\cup\Pi_{\emptyset T}, σ11F=σ12FΠF\sigma_{11^{*}}^{F}=\sigma_{12}^{F}\cup\Pi_{\emptyset F} , σ11exT=σ12exTΠexT\sigma_{11^{*}}^{exT}=\sigma_{12}^{exT}\cup\Pi_{\emptyset exT}, σ11exF=σ12exFΠexF\sigma_{11^{*}}^{exF}=\sigma_{12}^{exF}\cup\Pi_{\emptyset exF}; because any proposition that does not appear in σ12\sigma_{12} can maintain any truth value, the transition σ11\sigma_{11^{*}} ensures that all propositions that appear in σ23\sigma_{23} but not in σ12\sigma_{12} (i.e. ΠTΠexTΠFΠexF\Pi_{\emptyset T}\cup\Pi_{\emptyset exT}\cup\Pi_{\emptyset F}\cup\Pi_{\emptyset exF}) change their truth values, in any order, before any of the propositions that change truth values between the transitions (i.e. ΠFΠexTΠTΠexF\Pi_{F}\cup\Pi_{exT}\cup\Pi_{T}\cup\Pi_{exF}) do so.

Updating transitions in \mathcal{B}: Since we assume that every state in the Büchi automaton \mathcal{B} has a self transition, either e1e_{1} is a self-transition and e2e_{2} is not, or vice-versa; the approach in updating \mathcal{B} differs for the two cases.

Refer to caption
Figure 4: Updated Büchi automaton for Case 1 (e1e_{1} is a self-transition and e2e_{2} is not). The blue represents the original transitions, the pink represents the added intermediate states and transitions

Case 1: e1e_{1} is a self-transition and e2e_{2} is not (lines 1 - 1). We take advantage of the fact that e1e_{1} is a self-transition and add an intermediate state along with the transitions (z1,σ12,z1)(z_{1},\sigma_{12},z_{1^{*}}), (z1,σ11,z1)(z_{1^{*}},\sigma_{11^{*}},z_{1^{*}}), and (z1,σ23,z3)(z_{1^{*}},\sigma_{23},z_{3}). These transitions satisfy the self-transition e1e_{1} while also including constraints that must be enforced to ensure the robot’s continuous time execution of the actions do not violate any part of e2e_{2}.

Example: Given the Büchi automaton in Fig. 2, let e1=(1,σ11,i,1)e_{1}=(1,\sigma_{11,i},1), e2=(1,σ10,0)e_{2}=(1,\sigma_{10},0), where σ11,i\sigma_{11,i} and σ10\sigma_{10} are defined earlier in the example. Then σ11=({roomBc2,roomBc3},,{dockc1},)\sigma_{11^{*}}=(\{roomB_{c}^{2},roomB_{c}^{3}\},\emptyset,\{dock_{c}^{1}\},\emptyset). We add an intermediate state 11^{*} and the corresponding transitions (1,σ11,i,1)(1,\sigma_{11,i},1^{*}), (1,σ11,1)(1^{*},\sigma_{11^{*}},1^{*}), and (1,σ10,0)(1^{*},\sigma_{10},0). Fig. 4 shows the Büchi automaton with these updates.

Case 2: e2e_{2} is a self-transition and e1e_{1} is not. Because e1e_{1} is not a self-transition, we cannot add intermediate states between e1e_{1} and e2e_{2}. In this case, we modify e1e_{1} from (z1,σ12,z2)(z_{1},\sigma_{12},z_{2}) to (z1,σ11,z2)(z_{1},\sigma_{11^{*}},z_{2}). Intuitively, we are adding all the non-instantaneous propositions explicitly in σ23\sigma_{23} into σ12\sigma_{12}. Changing this transition does not affect the satisfiability of the original task, since the modification only adds more constraints on propositions that do not violate the original formula along the transition.

Example: Given the Büchi automaton in Fig. 2, let e1=(1,σ10,0)e_{1}=(1,\sigma_{10},0), e2=(0,σ00,0)e_{2}=(0,\sigma_{00},0) , where σ10\sigma_{10} is defined earlier in the example, and σ00=(,,{dockc1},)\sigma_{00}=(\emptyset,\emptyset,\{dock_{c}^{1}\},\emptyset). Since both ΠT\Pi_{\emptyset T} and ΠF\Pi_{\emptyset F} are empty, σ11\sigma_{11^{*}} and σ10\sigma_{10} are equivalent, and no updates to the Büchi automaton are necessary. However, since ΠTΠF={dockc1}\Pi_{T}\cup\Pi_{F}=\{dock_{c}^{1}\}, one and only one robot can be assigned binding 1. Thus, csingle={1}c_{single}=\{1\}.

Algorithm 1 outputs upd\mathcal{B}_{upd}, the updated Büchi automaton, EupdE_{upd}, the edges that have been modified/added, and (csingle,ccombo)(c_{single},c_{combo}), which include constraints on the bindings in which one and only one robot can be assigned to (i.e. csinglec_{single}), or bindings that a robot must be assigned either to all or none of those bindings (i.e. ccomboc_{combo}).

V-D Updating the Product Automaton

Input : ,upd,Eupd,𝒢j\mathcal{B},\mathcal{B}_{upd},E_{upd},\mathcal{G}_{j}
Output : 𝒢j,upd\mathcal{G}_{j,upd}
1
2if upd=\mathcal{B}_{upd}=\mathcal{B} then
3       return 𝒢j\mathcal{G}_{j}
4𝒢j,upd=𝒢j\mathcal{G}_{j,upd}=\mathcal{G}_{j}
5
6if |Eupd|>1|E_{upd}|>1 then
7       (z1,σ12,z1),(z1,σ11,z1),(z1,σ23,z3)=Eupd(z_{1},\sigma_{12},z_{1^{*}}),(z_{1^{*}},\sigma_{11^{*}},z_{1^{*}}),(z_{1^{*}},\sigma_{23},z_{3})=E_{upd}
8       𝒢j,upd=remove_edges(𝒢j,upd,(z2,σ23,z3))\mathcal{G}_{j,upd}=\textsc{remove\_edges}(\mathcal{G}_{j,upd},(z_{2},\sigma_{23},z_{3}))
9       upd=get_subBuchi(upd,Eupd)\mathcal{B}_{upd}^{\prime}=\textsc{get\_subBuchi}(\mathcal{B}_{upd},E_{upd})
10       Aj=get_subAgent(𝒢j,(z1,σ12,z2),(z2,σ23,z3))A_{j}^{\prime}=\textsc{get\_subAgent}(\mathcal{G}_{j},(z_{1},\sigma_{12},z_{2}),(z_{2},\sigma_{23},z_{3}))
11       𝒢j=Aj×upd\mathcal{G}_{j}^{\prime}=A_{j}^{\prime}\times\mathcal{B}_{upd}^{\prime}
12      
      // join two product automata
13       𝒢j,upd=𝒢j,upd𝒢j\mathcal{G}_{j,upd}=\mathcal{G}_{j,upd}\cup\mathcal{G}_{j}^{\prime}
14else if |Eupd|=1|E_{upd}|=1 then
15       (z1,σ11,z2)=Eupd(z_{1},\sigma_{11^{*}},z_{2})=E_{upd}
       // sub product automaton to check
16       𝒢j=get_subProd(𝒢j,(z1,σ12,z2))\mathcal{G}_{j}^{\prime}=\textsc{get\_subProd}(\mathcal{G}_{j},(z_{1},\sigma_{12},z_{2}))
17      for (q,q)δ𝒢j(q,q^{\prime})\in\delta_{\mathcal{G}_{j}^{\prime}} do
18             if not valid_edge((q,q),σ11)\textsc{valid\_edge}((q,q^{\prime}),\sigma_{11^{*}}) then
19                   𝒢j,upd.remove_edge(q,q)\mathcal{G}_{j,upd}.remove\_edge(q,q^{\prime})
20return 𝒢j,upd\mathcal{G}_{j,upd}
Algorithm 2 Update Robot jj’s Product Automaton

Because we are modifying the Büchi automaton as we search for an accepting trace through it, we also need to modify each robot’s product automaton 𝒢\mathcal{G} to check if the robot can synthesize controllers to satisfy the given trace in the Büchi automaton (Alg. 2). This is done for each transition we check in the Büchi automaton, when constructing the trace.

As mentioned in Sec. V-C, there are two types of modifications to the Büchi automaton depending on whether the first transition is a self-transition and the second is not, or vice-versa; as a result, there are two ways to update the product automaton. In both cases, we take advantage of the fact that σ12σ11\sigma_{12}\subseteq\sigma_{11^{*}} (i.e. the propositions in σ11\sigma_{11^{*}} may have constraints on the truth values of propositions in addition to the ones in σ12\sigma_{12}); rather than reconstructing robot jj’s product automaton 𝒢j\mathcal{G}_{j} by taking the entire cross product Aj×updA_{j}\times\mathcal{B}_{upd}, we modify portions of the existing 𝒢j\mathcal{G}_{j} based on the changes made to \mathcal{B} to get 𝒢jupd\mathcal{G}^{upd}_{j}.

Let the two transitions we checked in the original Büchi automaton \mathcal{B} be e1=(z1,σ12,z2),e2=(z2,σ23,z3)e_{1}=(z_{1},\sigma_{12},z_{2}),e_{2}=(z_{2},\sigma_{23},z_{3}), where σ12=(σ12T,σ12exT,σ12F,σ12exF)\sigma_{12}=(\sigma_{12}^{T},\sigma_{12}^{exT},\sigma_{12}^{F},\sigma_{12}^{exF}), σ23=(σ23T,σ23exT,σ23F,σ23exF)\sigma_{23}=(\sigma_{23}^{T},\sigma_{23}^{exT},\sigma_{23}^{F},\sigma_{23}^{exF}), and the set of updated transitions EupdE_{upd} is outputted by Alg. 1.

Case 1: e1e_{1} is a self-transition and e2e_{2} is not (i.e. |Eupd|>1|E_{upd}|>1). In this case, the transition e2e_{2} has been removed and replaced with intermediate states and associated transitions in the Büchi automaton (Alg. 1).

To update the product automaton, we first remove any transitions of the product automaton ((s,z2),(s,z3))δ𝒢j((s,z_{2}),(s^{\prime},z_{3}))\in\delta_{\mathcal{G}_{j}}, since we have also removed e2e_{2} from upd\mathcal{B}_{upd}. Then, we take the cross product only of the modified portions of each graph and add it to 𝒢j,upd\mathcal{G}_{j,upd}.

Case 2: e2e_{2} is a self-transition and e1e_{1} is not (i.e. |Eupd|=1|E_{upd}|=1). In this case, upd\mathcal{B}_{upd} does not have any new transitions, but σ12\sigma_{12} has been modified to become σ11\sigma_{11^{*}}. Thus, we check any transition in ((s,z1),(s,z2))δ𝒢j((s,z_{1}),(s^{\prime},z_{2}))\in\delta_{\mathcal{G}_{j}} to see if it is still valid based on (z1,σ11,z2)(z_{1},\sigma_{11^{*}},z_{2}), the updated transition in upd\mathcal{B}_{upd}.

V-E Robot Team Behavior

To find a team of robots that can satisfy the task, we need to find a trace in the Büchi automaton such that every binding is assigned, with each robot maintaining a consistent set of bindings throughout the entire trace.

In our prior work, we introduced a DFS algorithm to find a trace β\beta in the Büchi automaton, βA^\beta_{\hat{A}}, a team of robots A^\hat{A}, and corresponding binding assignments RA^R_{\hat{A}} to collectively execute discrete actions. We extend this framework to continuous actions so that the robots’ behaviors are guaranteed to satisfy the original specifications (Alg. 3). To do so, during the DFS, for each transition (z,σ,z)(z,\sigma,z^{\prime}) we check, we update the Büchi automaton if intermediate states are necessary (line 3). Each robot updates its product automaton, and determines which bindings it can satisfy (line 3).

We want the robot’s behavior to satisfy not only the current transition, but also the entire path with a fixed binding assignment. To ensure this, each robot’s assigned binding set rjr_{j} is first initialized to be the set of all possible binding assignments, and each robot removes binding assignments that are not possible with each iteration of the DFS algorithm (line 3). It does so by finding a trace through its product automaton following the current trace in the Büchi automaton, βA^Eupd\beta_{\hat{A}}\cup E_{upd}. The robots also take the binding constraints (csingle,ccombo)(c_{single},c_{combo}) into account, reducing the number of combinations of bindings the robots need to check (e.g. if ccombo={1,2}c_{combo}=\{1,2\} , then a robot assigned binding 1 must also be assigned binding 2; there is no need for the robot to check its ability to satisfy the bindings separately). If rj=r_{j}=\emptyset (i.e. the robot cannot be assigned any binding), we remove the robot from the team A^\hat{A} entirely.

csinglec_{single} is the set of bindings assignments for which exactly one robot must be assigned, but the framework may output a teaming assignment that includes multiple robots assigned those bindings. We keep track of these binding constraints and ask the user to choose one robot for each ccsinglec\in c_{single}.

Because we are using a DFS approach to find a viable team, the final teaming assignment may not be the globally optimal one. However, the framework is sound; it is guaranteed to find an assignment if one exists.

Input : A={A1,A2,,An}A=\{A_{1},A_{2},...,A_{n}\}, \mathcal{B}, G={𝒢1,𝒢2,𝒢n},APψG=\{\mathcal{G}_{1},\mathcal{G}_{2}...,\mathcal{G}_{n}\},AP_{\psi}
Output : β\beta, δself\delta_{self}, A^A\hat{A}\subseteq A, RA^R_{\hat{A}}, GA^,updG_{\hat{A}},\mathcal{B}_{upd}
1
2stack=stack=\emptyset, visited=visited=\emptyset
3 R={rk=2APψ|k={1,2,,n}}R=\{r_{k}=2^{AP_{\psi}}\setminus\emptyset\ |\ k=\{1,2,...,n\}\}
4 for e{(z,σ,z)δ|z=z0}e\in\{(z,\sigma,z^{\prime})\in\delta_{\mathcal{B}}\ |\ z=z_{0}\}  do
5       stack=stack{(e,R,[e],,G,)}stack=stack\cup\{(e,R,[e],{\mathcal{B},G,\emptyset})\}
6while stackstack\neq\emptyset do
7       ((z,σ,z),RA^,βA^,,GA^,C)=stack.pop()((z,\sigma,z^{\prime}),R_{\hat{A}},\beta_{\hat{A}},{\mathcal{B},G_{\hat{A}},C})=stack.pop()
8      
9      if (z,σ,z)visited(z,\sigma,z^{\prime})\not\in visited then
10             visited=visited(z,σ,z)visited=visited\cup(z,\sigma,z^{\prime})
             // update buchi automaton with intermediate states
11             if |βA^|>1|\beta_{\hat{A}}|>1 then
12                   e1=βA^[1],e_{1}=\beta_{\hat{A}}[-1], e2=(z,σ,z)e_{2}=(z,\sigma,z^{\prime})
13                   upd,Eupd,(call,cex)=update_buchi(,e1,e2)\mathcal{B}_{upd},E_{upd},(c_{all},c_{ex})=\textsc{update\_buchi}(\mathcal{B},e_{1},e_{2})
14            else
15                   upd,Eupd,(call,cex)=,,(,)\mathcal{B}_{upd},E_{upd},(c_{all},c_{ex})=\mathcal{B},\emptyset,(\emptyset,\emptyset)
16            for 𝒢jGA^\mathcal{G}_{j}\in G_{\hat{A}} do
17                   𝒢j,upd=update_product_aut(upd,Eupd,𝒢j)\mathcal{G}_{j,upd}=\textsc{update\_product\_aut}(\mathcal{B}_{upd},E_{upd},\mathcal{G}_{j})
18            
19            for rjRA^r_{j}\in R_{\hat{A}}  do
20                   rj=update_bindings(rjr_{j}^{\prime}=\textsc{update\_bindings}(r_{j}, 𝒢j,upd,βA^Eupd,(call,cex)){\mathcal{G}_{j,upd},\beta_{\hat{A}}\cup E_{upd},(c_{all},c_{ex})})
21                   if rj=r_{j}^{\prime}=\emptyset then
22                         RA^=RA^rjR_{\hat{A}}=R_{\hat{A}}\setminus r_{j}, GA^=GA^𝒢j{G_{\hat{A}}=G_{\hat{A}}\setminus\mathcal{G}_{j}}
23                  else
24                         RA^=(RA^rj)rjR_{\hat{A}}=(R_{\hat{A}}\setminus r_{j})\cup r_{j}^{\prime}
25            
26            if j(RjRA^)=APψ\bigcup_{j}(R_{j}\in R_{\hat{A}})=AP_{\psi} then
27                  
28                  if zFz^{\prime}\in F then
29                         β,δself=parse_trace(βA^)\beta,\delta_{self}=\textsc{parse\_trace}(\beta_{\hat{A}})
30                         return β,δself,RA^,upd,C{(call,cex)}\beta,\delta_{self},R_{\hat{A}},{\mathcal{B}_{upd},C\cup\{(c_{all},c_{ex})\}}
31                  E={(z,σ,z′′)δ}E=\{(z^{\prime},\sigma^{\prime},z^{\prime\prime})\in\delta_{\mathcal{B}}\}
32                  for (z,σ,z′′)E(z^{\prime},\sigma^{\prime},z^{\prime\prime})\in E  do
33                         if (z=z and zz′′)(z=z^{\prime}\text{ and }z^{\prime}\neq z^{\prime\prime}) or (zz and z=z′′)(z\neq z^{\prime}\text{ and }z^{\prime}=z^{\prime\prime})  then
34                               stack=stack{(z,σ,z′′),RA^stack=stack\cup\{(z^{\prime},\sigma^{\prime},z^{\prime\prime}),R_{\hat{A}}, βA^Eupd,upd,GA^,C{(call,cex)}\beta_{\hat{A}}\cup E_{upd},\mathcal{B}_{upd},G_{\hat{A}},C\cup\{(c_{all},c_{ex})\}
Algorithm 3 Find Accepting Trace for Robot Team

V-F Synthesis and Execution of Control and Synchronization Policies

To guarantee that the behavior of the robots do not violate the original task, the robots must implement synchronization policies to transition to the next non-intermediate state in upd\mathcal{B}_{upd} at the same time. The algorithm (Alg. 4) is similar to [1]; a robot jj first synthesizes its behavior bjb_{j} for the entirety of the task that satisfies the collective trace in the Büchi automaton β\beta (function find_behavior, line 4). For each transition (z,σ,z)(z,\sigma,z^{\prime}) in β\beta, the robot parses out bjzzb_{j}^{zz^{\prime}}, the behavior that correlates to (z,σ,z)(z,\sigma,z^{\prime}) (function sub_behavior, line 4). Before it executes this behavior, it checks if it is required to participate in the synchronization step. It participates if 1) zz^{\prime} is not an intermediate state, 2) rjr_{j} contains a binding ρ\rho required by σ\sigma and 3) is not the only robot assigned bindings from σ\sigma (line 4). If the robot satisfied these criteria, its binding assignment rjr_{j} is added to R¯\overline{R}, which contains the binding assignments of every robot that needs to participate in the synchronization step at state zz^{\prime}.

One difference of this algorithm compared to our previous approach [1] is that we do not need to execute the synchronization policy if zz^{\prime} is an intermediate state (Alg. 4. lines (4 - 4)), since the synchronization is only required on the transitions of the original Büchi automaton.

The other key difference is in lines 4 - 4 of Alg. 4. Because instantaneous actions may need to synchronize when another action finishes (e.g. a robot must take a camera as soon as another robot enters room B), robots also need to communicate when all of their non-instantaneous actions finish executing (e.g. when roomBcroomBc is true) by executing the function execute_noninst (line 4). As soon as all the non-instantaneous actions across the robots in R¯\overline{R} are complete, the robots execute their instantaneous actions (function execute_inst, line 4).

The waiting state for each robot zwaitz_{wait} is the penultimate state in its behavior, bj[1]b_{j}[\ell-1]. Each robot stays in zwaitz_{wait} until all the other robots in R¯\overline{R} are also in their waiting states. Then, the robots execute the last step in their behavior, bj[]b_{j}[\ell], synchronously.

Input : 𝒢j\mathcal{G}_{j}, rjr_{j}, RA^R_{\hat{A}}, β\beta, δself\delta_{self}
1
2bj=find_behavior(𝒢j,rj,β,δself)b_{j}=\textsc{find\_behavior}(\mathcal{G}_{j},r_{j},\beta,\delta_{self})
3for (z,σ,z)β(z,\sigma,z^{\prime})\in\beta do
4       bjzz=sub_behavior(bj,(z,σ,z))b_{j}^{zz^{\prime}}=\textsc{sub\_behavior}(b_{j},(z,\sigma,z^{\prime}))
5       if z=zz^{\prime}=z^{*} then
6             p=()p=()
7             execute(bjzz,p)\textsc{execute}(b_{j}^{zz^{\prime}},p)
8             continue
9      
10      R¯={rkRA^|rk𝔅(σ)}\overline{R}=\{r_{k}\in R_{\hat{A}}\ |\ r_{k}\cap\mathfrak{B}(\sigma)\neq\emptyset\}
11       if rjR¯r_{j}\not\in\overline{R} or R¯={rj}\overline{R}=\{r_{j}\}  then
12             p=()p=()
13             execute(bj,p)\textsc{execute}(b_{j},p)
14      else
15             p=(j,z,0)p=(j,z^{\prime},0), =length(bj)\ell=length(b_{j})
16             execute(bjzz[1:1],p)\textsc{execute}(b_{j}^{zz^{\prime}}[1:\ell-1],p)
17             zwait=bj[1]z_{wait}=b_{j}[\ell-1], P={j}P=\{j\}
18             while iP(riR¯)𝔅(σ)\bigcup_{i\in P}(r_{i}\in\overline{R})\neq\mathfrak{B}(\sigma) do
19                   p=(j,z,1)p=(j,z^{\prime},1)
20                   execute(zwait,p)\textsc{execute}(z_{wait},p)
21                   P=j{k|(k,z,1)receive()}P=j\cup\{k\ |\ (k,z^{\prime},1)\in\textsc{receive}()\}
22             Φ=(j,z,0)\Phi=(j,z^{\prime},0)
23             execute_noninst(bjzz[],Φ)\textsc{execute\_noninst}(b_{j}^{zz^{\prime}}[\ell],\Phi)
24             execute_inst(bjzz[],())\textsc{execute\_inst}(b_{j}^{zz^{\prime}}[\ell],())
Algorithm 4 Synthesize Robot jj’s Behavior

VI Results

VI-A Demonstrations

We demonstrate our framework through two different collaborative high-level tasks, executed on physical hardware. We use 4 robots - two Hello Robot Stretch RE1, one Hello Robot Stretch 2, and a Clearpath Boxer with a Kinova Gen3 arm. We use an Optitrack motion capture system to track the robots and the environment. The setup is shown in Fig. 5. Their capabilities are the same as those listed in Sec. IV:

Λgreen={λ𝑚𝑜𝑡,λarm,λcamera},L(s0)={roomDc}\Lambda_{green}=\{\lambda_{\mathit{mot}},\lambda_{arm},\lambda_{camera}\},L(s_{0})=\{roomD_{c}\}
Λblue={λ𝑚𝑜𝑡,λbeep},L(s0)={roomCc}\Lambda_{blue}=\{\lambda_{\mathit{mot}},\lambda_{beep}\},L(s_{0})=\{roomC_{c}\}
Λorange={λ𝑚𝑜𝑡,λarm},L(s0)={roomEc}\Lambda_{orange}=\{\lambda_{\mathit{mot}},\lambda_{arm}\},L(s_{0})=\{roomE_{c}\}
Λpink={λ𝑚𝑜𝑡,λbeep,λcam,λscan}\Lambda_{pink}=\{\lambda_{\mathit{mot}},\lambda_{beep},\lambda_{cam},\lambda_{scan}\}, L(s0)={roomEc}L(s_{0})=\{roomE_{c}\}

where the green and pink robots are Hello Robot Stretch RE1s, the blue robot is a Hello Robot Stretch 2, and the orange robot is the Clearpath Boxer with a Kinova Gen3 arm. Although all the Hello Robot Stretch robots have arms, we treat the blue and pink robots as not having those capabilities. The demonstrations of the full behavior is shown in the accompanying video111https://youtu.be/DiWjqXHQjmI.

Refer to caption
Figure 5: Initial setup on the physical system

VI-B Example: Task 1

Refer to caption
Figure 6: Robots executing task 1. The boxes on the right in each frame represents the pink and green robots’ cameras.

We implement our framework for the team of robots to satisfy the task defined in Eq. 4. The team created by the framework is A^={\hat{A}=\{AgreenA_{green}, AblueA_{blue}, AorangeA_{orange}, Apink}A_{pink}\} with binding assignments rgreen={2,3}r_{green}=\{2,3\}, rblue={1},rorange={1},rpink={2,3}r_{blue}=\{1\},r_{orange}=\{1\},r_{pink}=\{2,3\} with the constraints call={{1}}c_{all}=\{\{1\}\}. In this case, exactly one robot can be assigned binding 1, so the user chooses between AblueA_{blue} and AorangeA_{orange} to be part of the team. If we choose between the two based on minimizing cost, the final team is A^={\hat{A}=\{AgreenA_{green}, ApinkA_{pink}, Ablue}A_{blue}\}.

Fig. 6 provides key frames in the robots’ execution of the task. The boxes on the right in each frame represents the pink and green robots’ cameras. We can see that the blue robot waits outside the dock area while the pink and green robots make their way to roomB (Fig. 6b). After they are in roomB, the blue robot moves to the dock area (Fig. 6c); as soon as the blue robot enters that room, the other robots immediately execute the instantaneous action of taking a picture (Fig. 6d).

VI-C Example: Task 2

Refer to caption
Figure 7: Robots executing task 2

For this task, we use the same environment with three available robots, AgreenA_{green}, AorangeA_{orange}, and ApinkA_{pink}. Their capabilities and initial positions are the same as in the previous example.

The task is φψ=φ1ψφ2ψ\varphi^{\psi}=\varphi^{\psi}_{1}\wedge\varphi^{\psi}_{2}, where

φ1ψ\displaystyle\varphi^{\psi}_{1} =((beepdockc)12\displaystyle=\Diamond\big{(}(beep\wedge dock_{c})^{1\vee 2} (13a)
(pickupstoragec)1)\displaystyle\>\wedge\Diamond(pickup\wedge storage_{c})^{1}\big{)}
φ2ψ\displaystyle\varphi^{\psi}_{2} =¬roomBc123𝒰(pushchallc)3\displaystyle=\neg roomB_{c}^{1\wedge 2\wedge 3}\ \mathcal{U}\ (push_{c}\wedge hall_{c})^{3} (13b)

φ1ψ\varphi^{\psi}_{1} captures “robot(s) with bindings 1 or 2 should beep at the dock, then robot(s) with binding 1 should pickup packages at the storage. φ2ψ\varphi^{\psi}_{2} enforces “none of the robots can be in room B until the cart in the hallway is pushed out of the way”.

In this example, pushcpush_{c}, pickupcpickup_{c}, and the location completion propositions make up the set of APnoninstAP_{non-inst}, while beepbeep is an instantaneous action. To guarantee the robots do not violate φ2ψ\varphi^{\psi}_{2}, any robot assigned binding 3 must move into the hallway first before any robots can be in room B. If we assume discrete execution of actions, this constraint is not necessary; all the robots can move into the respective areas simultaneously.

The final team is A^={\hat{A}=\{AgreenA_{green}, AorangeA_{orange}, Apink}A_{pink}\} with binding assignments rgreen={1,3}r_{green}=\{1,3\}, rorange={1,3},rpink={2}r_{orange}=\{1,3\},r_{pink}=\{2\}. Snapshots of their behavior is shown in Fig. 7. We can see that the green and orange robots first move into the hall (Fig. 7b) to push the cart before the pink robot passes through roomB (Fig. 7c) to make its way to the dock. The pink robot beeps immediately as it enter the dock (Fig. 7d). Then, the green and orange robots move to pickup their respective packages at the dock and synchronize the pickup action (Fig. 7e). We assume the robots have low-level controllers to coordinate executing the pushpush and pickuppickup actions. The robots begin pushing the cart together when they have both grabbed it. The action pickuppickup includes reorienting, reaching, and grasping the packages; the robots begin executing this at the same time (i.e. they begin reorienting simultaneously).

VI-D Computational Performance

Refer to caption
(a)
Refer to caption
(b)
Figure 8: Comparing computation times between the instantaneous and non-instantaneous actions frameworks as the number of robots increases (8(a)) and the number of bindings increases (8(b)). The error bars represent min/max values.

We compare the computation performance (without significant code optimization) of the approach for synthesizing a team of robots and their corresponding binding assignments for instantaneous versus non-instantaneous actions.

Effects of number of robots: We analyze the effect of increasing the number of robots while keeping the task specification the same (task 1, Eq. 4). This task requires the generation of intermediate states when considering non-instantaneous actions.

The instantaneous approach involves decentralized pre-processing for each robot jj’s possible combination of binding assignments for each transition in the Büchi automaton before conducting the DFS algorithm to find an overall teaming plan. As a result, this framework is largely agnostic to the number of robots. However, the approach for non-instantaneous actions is centralized, as the DFS algorithm may need to update each robot’s product automaton during each iteration. As a result, while both framework’s scale linearly with the number of robots, there is a larger impact on the computational performance of the framework under the assumption of non-instantaneous actions.

Effects of number of bindings: We consider the effect of increasing the number of bindings while keeping the number of robots fixed at 4, but randomizing their capabilities with each simulation. We add more bindings to the task specification through conjunction. By doing so, we increase the number of bindings, but keep the number of edges in the Büchi automaton the same.

In both the instantaneous and non-instantaneous actions frameworks, we need to store all possible binding assignments for the current team of robots as we search for a possible trace in the Büchi automaton. As a result, both the space and time complexity for each approach are exponential with the number of bindings. The non-instantaneous actions framework scales worse with the number of bindings because we determine the possible binding assignments for each robot with every transition in the DFS; in the instantaneous action framework, each robot had performed this computation in a decentralized manner before conducting the DFS algorithm.

VII Conclusion

We introduced a method for control synthesis for a heterogeneous multi-robot system to satisfy collaborative tasks in continuous time, where actions may take varying duration of time to complete. We presented a synthesis approach to automatically generate a teaming assignment and corresponding discrete behavior that is correct-by-construction for continuous execution and ensured collaborative portions of the task are satisfied. We implemented our approach on a physical multi-robot system in two warehouse scenarios.

In the future, we plan to explore different notions of optimality when finding a teaming plan, as well as implement methods for robots to respond to capability failures or modifications in real time.

References

  • [1] A. Fang and H. Kress-Gazit, “High-level, collaborative task planning grammar and execution for heterogeneous agents,” in Proceedings of the 23rd International Conference on Autonomous Agents and Multiagent Systems, AAMAS ’24, (Richland, SC), p. 544–552, International Foundation for Autonomous Agents and Multiagent Systems, 2024.
  • [2] N. Atay and B. Bayazit, “Mixed-integer linear programming solution to multi-robot task allocation problem,” 01 2006.
  • [3] E. Suslova and P. Fazli, “Multi-robot task allocation with time window and ordering constraints,” in 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 6909–6916, 2020.
  • [4] A. T. Tolmidis and L. Petrou, “Multi-objective optimization for dynamic task allocation in a multi-robot system,” Engineering Applications of Artificial Intelligence, vol. 26, no. 5, pp. 1458–1468, 2013.
  • [5] O. Cheikhrouhou and I. Khoufi, “A comprehensive survey on the multiple traveling salesman problem: Applications, approaches and taxonomy,” Computer Science Review, vol. 40, p. 100369, 2021.
  • [6] K. Braekers, K. Ramaekers, and I. Van Nieuwenhuyse, “The vehicle routing problem: State of the art classification and review,” Computers & Industrial Engineering, vol. 99, pp. 300–313, 2016.
  • [7] L. Poudel, W. Zhou, and Z. Sha, “Resource-Constrained Scheduling for Multi-Robot Cooperative Three-Dimensional Printing,” Journal of Mechanical Design, vol. 143, 04 2021. 072002.
  • [8] W. Wu, X. Wang, and N. Cui, “Fast and coupled solution for cooperative mission planning of multiple heterogeneous unmanned aerial vehicles,” Aerospace Science and Technology, vol. 79, pp. 131–144, 2018.
  • [9] T. Holvoet, D. Weyns, N. Boucke, and B. Demarsin, “Dyncnet: A protocol for dynamic task assignment in multiagent systems,” in 2007 First International Conference on Self-Adaptive and Self-Organizing Systems, (Los Alamitos, CA, USA), pp. 281–284, IEEE Computer Society, jul 2007.
  • [10] Z. Zhen, L. Wen, B. Wang, Z. Hu, and D. Zhang, “Improved contract network protocol algorithm based cooperative target allocation of heterogeneous uav swarm,” Aerospace Science and Technology, vol. 119, p. 107054, 2021.
  • [11] B. Xu, Z. Yang, Y. Ge, and Z. Peng, “Coalition formation in multi-agent systems based on improved particle swarm optimization algorithm,” International Journal of Hybrid Information Technology, vol. 8, pp. 1–8, 03 2015.
  • [12] Z. Liu, X.-G. Gao, and X.-W. Fu, “Coalition formation for multiple heterogeneous uavs cooperative search and prosecute with communication constraints,” in 2016 Chinese Control and Decision Conference (CCDC), pp. 1727–1734, 2016.
  • [13] X. Luo and M. M. Zavlanos, “Temporal logic task allocation in heterogeneous multirobot systems,” IEEE Transactions on Robotics, pp. 1–20, 2022.
  • [14] Y. E. Sahin, P. Nilsson, and N. Ozay, “Synchronous and asynchronous multi-agent coordination with cltl+ constraints,” in 2017 IEEE 56th Annual Conference on Decision and Control (CDC), pp. 335–342, 2017.
  • [15] J. Chen, R. Sun, and H. Kress-Gazit, “Distributed control of robotic swarms from reactive high-level specifications,” in 2021 IEEE 17th International Conference on Automation Science and Engineering (CASE), pp. 1247–1254, 2021.
  • [16] K. Leahy, Z. Serlin, C.-I. Vasile, A. Schoer, A. M. Jones, R. Tron, and C. Belta, “Scalable and robust algorithms for task-based coordination from high-level specifications (scratches),” IEEE Transactions on Robotics, vol. 38, no. 4, pp. 2516–2535, 2022.
  • [17] D. Gundana and H. Kress-Gazit, “Event-based signal temporal logic synthesis for single and multi-robot tasks,” IEEE Robotics and Automation Letters, vol. 6, no. 2, pp. 3687–3694, 2021.
  • [18] A. T. Buyukkocak, D. Aksaray, and Y. Yazıcıoğlu, “Planning of heterogeneous multi-agent systems under signal temporal logic specifications with integral predicates,” IEEE Robotics and Automation Letters, vol. 6, no. 2, pp. 1375–1382, 2021.
  • [19] J. Tumova and D. V. Dimarogonas, “Multi-agent planning under local ltl specifications and event-based synchronization,” Automatica, vol. 70, pp. 239–248, 2016.
  • [20] W. Liu, K. Leahy, Z. Serlin, and C. Belta, “Robust multi-agent coordination from catl+ specifications,” 2023.
  • [21] V. Raman, C. Finucane, and H. Kress-Gazit, “Temporal logic robot mission planning for slow and fast actions,” in 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 251–256, 2012.
  • [22] S. Moarref and H. Kress-Gazit, “Decentralized control of robotic swarms from high-level temporal logic specifications,” in 2017 International Symposium on Multi-Robot and Multi-Agent Systems (MRS), pp. 17–23, 2017.
  • [23] E. A. Emerson, “Temporal and modal logic,” in Formal Models and Semantics (J. Van Leeuwen, ed.), Handbook of Theoretical Computer Science, pp. 995–1072, Amsterdam: Elsevier, 1990.
  • [24] C. Baier and J.-P. Katoen, Principles of Model Checking. The MIT Press, 2008.
  • [25] A. Fang and H. Kress-Gazit, “Automated task updates of temporal logic specifications for heterogeneous robots,” in 2022 International Conference on Robotics and Automation (ICRA), pp. 4363–4369, 2022.
  • [26] A. Duret-Lutz, A. Lewkowicz, A. Fauchille, T. Michaud, E. Renault, and L. Xu, “Spot 2.0 — a framework for LTL and ω\omega-automata manipulation,” in Proceedings of the 14th International Symposium on Automated Technology for Verification and Analysis (ATVA’16), vol. 9938 of Lecture Notes in Computer Science, pp. 122–129, Springer, Oct. 2016.