Continuous Execution of High-Level Collaborative Tasks for Heterogeneous Robot Teams
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 , where are Boolean variables [23]. The atomic propositions represent an abstraction of robot actions. For example, captures a robot taking a picture.
Syntax: We use the following syntax to define an LTL formula:
where and are Boolean operators (“not” and “or”, respectively), and and (“next” and “until”, respectively) are temporal operators. Using these, we can also define conjunction , implication , eventually , and always .
Semantics: The semantics of an LTL formula are defined over an infinite trace , where is the set of that are true at step . We use to denote that the trace satisfies LTL formula .
Intuitively, is satisfied if is satisfied in the next step of the sequence; is satisfied if is true at some step in the sequence; is satisfied if is true at every step in ; is satisfied if remains true until becomes true. See [23] for the full semantics.
II-B Büchi Automata
An LTL formula can be translated into a Nondeterministic Büchi Automaton that accepts infinite traces if and only if they satisfy . A Büchi automaton is a tuple , where is the set of states, is the initial state, is the input alphabet, is the transition relation, and is a set of accepting states. An infinite run of over a word is an infinite sequence of states such that . A run is accepting if and only if Inf() , where Inf() is the set of states that appear in 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) , and its corresponding completion proposition, . is true at iff the action associated with is being executed at position in the trace; is true at iff the action associated with has been completed at position in the trace. For example, indicates that the robot is currently moving towards room A; indicates the robot has finished executing the action and is currently in room A.
The set of all is composed of the subsets and , which are the sets of propositions representing instantaneous actions and non-instantaneous actions, respectively. Formally, an action is instantaneous iff , where is the timing function that outputs the amount of time it takes for the action to be executed; thus, . Similarly, an action is considered non-instantaneous iff . For these types of actions, . For example, for the action of beeping, and therefore . In contrast, (i.e. moving into room A takes time), so .
Note that, for synchronization purposes, we assume that robots can coordinate such that they can execute an action simultaneously, so all are in the set of . For example, but ; (note that, for instantaneous actions, and have equivalent meanings).
III-B Robot Model
Based on our prior work [25], each robot is modeled based on its set of capabilities, . Each capability is a weighted transition system , where is a finite set of states, is the initial state, is the set of atomic propositions representing the actions the capability can execute, is a transition relation, is the labeling function, and 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 is the cross product of its capabilities: such that . is the set of states, is the initial state, is the set of propositions, is the transition relation, is the labeling function, and is the cost function (a function of ). More details on the full definition can be found in [25]. See Fig. 1 for an example of a robot model.

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 recursively over LTL and binding formulas.
(1) | ||||
(2) | ||||
(3) |
where , the binding formula, is a Boolean formula excluding negation over the binding propositions , and is an LTL formula consisting of the set of propositions .
Semantics: The semantics of an LTLψ formula are defined over the team trace , where each is the trace for robot ; and the set of binding assignments , where is the set of bindings in that are assigned to robot . A robot’s binding assignment does not change throughout the task execution (i.e. remains the same). For example, indicates that robot 1 is assigned binding 2, and robot 2 is assigned bindings 1 and 3.
Given a set of binding propositions , outputs all possible combinations of that satisfy . For example, . We say that a team of robots satisfies the formula if and only if a binding assignment exists in such that all the bindings are assigned to (at least one) robot, and the behavior of all robots with these binding assignments satisfy . 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:
-
•
iff s.t. () and ( s.t. , )
-
•
iff s.t. () and ( s.t. , )
-
•
iff s.t. () and ( s.t. , )
-
•
iff and
-
•
iff or
-
•
iff
-
•
iff s.t. and
-
•
iff
Remark 1.
The notation and are equivalent. For example, .
Remark 2.
There is an important distinction between and . requires that the traces of all robots with binding assignments that satisfy , satisfy . requires the formula to be violated; at least one robot’s trace with a binding assignment that satisfies does not satisfy (equivalently, satisfies ).
Remark 3.
Unique to LTLψ is the ability to encode constraints either on all robots or on at least one robot. captures “all robots assigned a binding in must satisfy ”; captures “at least one robot assigned a binding in satisfies ”. This allows the same binding to be assigned to multiple robots, but only one of those robots needs to satisfy . This can be especially valuable when encoding safety requirements; for example, the formula 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

(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 heterogeneous robots and a task in LTLψ, find a team of robots , their binding assignments , and synthesize behavior for each robot such that and can by design be implemented in continuous execution (i.e., the physical execution of does not violate any part of ). 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 and the robot model has a self-transition (i.e. the robot can wait in any state).
Example: Let there be four robots , , , in a warehouse environment (Fig. 3). The set of all capabilities is , where is the motion model representing how the robots can move through the environment. represents a robotic manipulator; the arm can pick up and drop off packages, as well as push boxes. , , and are a robot’s ability to beep, take a picture, and scan, respectively. and execute non-instantaneous actions; the remaining capabilities contain only instantaneous actions.
The robots’ capabilities and labels on their initial states are:
,
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).

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 for the task (Sec. V-A). Each robot then constructs a product automaton (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 to an accepting cycle. For every transition in the trace, every proposition in 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 (i.e. the formula contains only ). For example, the formula is rewritten as .
Using and , we define , where and , . 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 conjunctive clauses with 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 , are Boolean formulas over , the atomic propositions that appear in . In this work, for a Büchi automaton of an LTLψ formula, , where contains the set of propositions that must be true/false for all robots ( and ), called for all propositions, and the set of propositions that must be true/false for at least one robot ( and ), called there exists propositions. are the set of propositions in which is true; are the set of propositions in which is true. Any proposition that does not appear in can maintain any truth value.
We modify the definition of compared to our prior work [1], where we assumed instantaneous robot actions; there, . 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 , only one robot assigned binding needs to execute . However, since the robots do not coordinate, if there are multiple robots assigned , they all satisfy (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 . 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 . .
Definition 1 (Binding Transition Function).
such that for is the set .
outputs the set of bindings that appear in a Büchi transition label . For example, .
Definition 2 (Binding Set Function).
such that for is the set .
outputs the set of bindings in a given set of LTLψ propositions . For example, for , ; for , .
Definition 3 (Capability Function).
such that for , , where for , .
and are the sets of for all propositions that are True/False and appear with binding in label of a Büchi transition and must be True/False for all robots assigned binding ; and are defined similarly but for there exists propositions with binding . For example, for , (for binding 2, the relevant propositions are and , both of which must be true and are for all propositions, i.e. the set ), and ( is the only proposition with the binding 1 and is in ).
Definition 4 (Binding Assignment Function).
Given a robot model and a label , and .
To synthesize behavior for a robot, we find the minimum cost accepting trace in its product automaton , where is the robot model, and is the Büchi automaton.
Given a transition , generates all possible combinations of binding propositions that can be assigned to a robot to satisfy . A robot can be assigned binding if and only if two conditions hold on the robot’s next state, : 1) the state label of contains all propositions that appear in either or as , and 2) the state label of does not contain any propositions that appear in or as .
A binding assignment can contain any binding propositions not in , since there are no propositions required by those bindings. In addition, it follows from condition (2) that if a proposition is in and is not in (e.g. and the robot does not have the capability ), can still be assigned to robot .
Given the binding assignment function , and as shown in [1], we can now define the product automaton:
Definition 5 (Product Automaton).
, where
-
•
is a finite set of states
-
•
is the initial state
-
•
is the transition relation, where for and , if and only if and such that and
-
•
is the labeling function s.t. for ,
-
•
is the cost function s.t. for , , ,
-
•
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 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 (the inner self-transition along state 1) and of the Büchi automaton in Fig 2, where , . 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 does not explicitly assign truth values to and (i.e. these propositions can have any truth value over ) in order to enforce that all the robots assigned bindings 2 and 3 enter room B at some point before executing the transition . For clarity in the remainder of the paper, we define a proposition to be assigned an explicit truth value over a transition if it appears in , i.e. . If a proposition is not explicitly in , it can maintain any truth value over that transition.
To automatically construct intermediate transitions, we first define the intermediate propositions function, :
Definition 6 (Intermediate Propositions Function).
such that for , , where
, , , and are the sets of LTLψ propositions corresponding to non-instantaneous actions that are assigned truth values over , respectively. For example, in Fig. 2 where , the intermediate propositions are , since all the motion propositions are non-instantaneous; is instantaneous and therefore omitted from .
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 be labels of two transitions in the Büchi automaton, and . To categorize how these propositions change their truth values, we define the following sets (Alg. 1, line 1):
(5) | ||||
(6) |
are the sets of non-instantaneous for all propositions that explicitly change truth values between and .
(7) | ||||
(8) |
include any non-instantaneous proposition that is a there exists proposition in that explicitly changes truth values between and .
(9) | ||||
(10) | ||||
(11) | ||||
(12) |
are the sets of non-instantaneous propositions that are assigned truth values in but not in .
Example: Task 1. In Fig. 2, consider the two transitions , , where is the inner self-transition on state 1, and . Then , ; the remaining sets are empty.
Violations of the task may occur when the robots execute a transition in the Büchi automaton . Thus, to prevent any violations, we check two sequential transitions in , , and update the Büchi automaton if a specific ordering of propositions is necessary. When there is at least one non-instantaneous proposition that changes truth values along , 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 () and at least one of them explicitly changes truth values (, 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, and , . In , we require all robots assigned binding 1 to not be in the dock, and in the next transition , 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 (in this case, binding 1). The same constraints apply if multiple bindings are present (e.g. if , 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 .
Similar constraints apply when , i.e. multiple there exists propositions change truth values. In this case, for each proposition in , we require that at least one robot assigned will change its truth value of across the two transitions. For instance, if , ), 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 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 , 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 . Note that the constraints are not necessary when ; in this case, only one robot assigned 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 , we generate an intermediate transition (line 1), where , , , ; because any proposition that does not appear in can maintain any truth value, the transition ensures that all propositions that appear in but not in (i.e. ) change their truth values, in any order, before any of the propositions that change truth values between the transitions (i.e. ) do so.
Updating transitions in : Since we assume that every state in the Büchi automaton has a self transition, either is a self-transition and is not, or vice-versa; the approach in updating differs for the two cases.

Case 1: is a self-transition and is not (lines 1 - 1). We take advantage of the fact that is a self-transition and add an intermediate state along with the transitions , , and . These transitions satisfy the self-transition 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 .
Example: Given the Büchi automaton in Fig. 2, let , , where and are defined earlier in the example. Then . We add an intermediate state and the corresponding transitions , , and . Fig. 4 shows the Büchi automaton with these updates.
Case 2: is a self-transition and is not. Because is not a self-transition, we cannot add intermediate states between and . In this case, we modify from to . Intuitively, we are adding all the non-instantaneous propositions explicitly in into . 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 , , where is defined earlier in the example, and . Since both and are empty, and are equivalent, and no updates to the Büchi automaton are necessary. However, since , one and only one robot can be assigned binding 1. Thus, .
Algorithm 1 outputs , the updated Büchi automaton, , the edges that have been modified/added, and , which include constraints on the bindings in which one and only one robot can be assigned to (i.e. ), or bindings that a robot must be assigned either to all or none of those bindings (i.e. ).
V-D Updating the 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 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 (i.e. the propositions in may have constraints on the truth values of propositions in addition to the ones in ); rather than reconstructing robot ’s product automaton by taking the entire cross product , we modify portions of the existing based on the changes made to to get .
Let the two transitions we checked in the original Büchi automaton be , where , , and the set of updated transitions is outputted by Alg. 1.
Case 1: is a self-transition and is not (i.e. ). In this case, the transition 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 , since we have also removed from . Then, we take the cross product only of the modified portions of each graph and add it to .
Case 2: is a self-transition and is not (i.e. ). In this case, does not have any new transitions, but has been modified to become . Thus, we check any transition in to see if it is still valid based on , the updated transition in .
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 in the Büchi automaton, , a team of robots , and corresponding binding assignments 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 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 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, . The robots also take the binding constraints into account, reducing the number of combinations of bindings the robots need to check (e.g. if , 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 (i.e. the robot cannot be assigned any binding), we remove the robot from the team entirely.
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 .
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.
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 at the same time. The algorithm (Alg. 4) is similar to [1]; a robot first synthesizes its behavior for the entirety of the task that satisfies the collective trace in the Büchi automaton (function find_behavior, line 4). For each transition in , the robot parses out , the behavior that correlates to (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) is not an intermediate state, 2) contains a binding required by and 3) is not the only robot assigned bindings from (line 4). If the robot satisfied these criteria, its binding assignment is added to , which contains the binding assignments of every robot that needs to participate in the synchronization step at state .
One difference of this algorithm compared to our previous approach [1] is that we do not need to execute the synchronization policy if 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 is true) by executing the function execute_noninst (line 4). As soon as all the non-instantaneous actions across the robots in are complete, the robots execute their instantaneous actions (function execute_inst, line 4).
The waiting state for each robot is the penultimate state in its behavior, . Each robot stays in until all the other robots in are also in their waiting states. Then, the robots execute the last step in their behavior, , synchronously.
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:
,
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.

VI-B Example: Task 1

We implement our framework for the team of robots to satisfy the task defined in Eq. 4. The team created by the framework is , , , with binding assignments , with the constraints . In this case, exactly one robot can be assigned binding 1, so the user chooses between and to be part of the team. If we choose between the two based on minimizing cost, the final team is , , .
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

For this task, we use the same environment with three available robots, , , and . Their capabilities and initial positions are the same as in the previous example.
The task is , where
(13a) | ||||
(13b) |
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. 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, , , and the location completion propositions make up the set of , while is an instantaneous action. To guarantee the robots do not violate , 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 , , with binding assignments , . 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 and actions. The robots begin pushing the cart together when they have both grabbed it. The action 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


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 ’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 -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.