Multi-Robot Task Planning under Individual and CollaborativeTemporal Logic Specifications

Ruofei Bai1, Ronghao Zheng1,2,†, Meiqin Liu1,2, and Senlin Zhang1,2

Abstract— This paper investigates the task coordination ofmulti-robot where each robot has a private individual temporallogic task specification; and also has to jointly satisfy aglobally given collaborative temporal logic task specification. Toefficiently generate feasible and optimized task execution plansfor the robots, we propose a hierarchical multi-robot temporaltask planning framework, in which a central server allocatesthe collaborative tasks to the robots, and then individual robotscan independently synthesize their task execution plans in adecentralized manner. Furthermore, we propose an executionplan adjusting mechanism that allows the robots to itera-tively modify their execution plans via privacy-preserved inter-agent communication, to improve the expected actual executionperformance by reducing waiting time in collaborations forthe robots. The correctness and efficiency of the proposedmethod are analyzed and also verified by extensive simulationexperiments.

I. INTRODUCTION

Multi-robot task planning widely exists in many areas,such as smart logistics, autonomous inspection, intelligentmanufacturing, etc. Planning methods based on model check-ing theories, such as linear temporal logic (LTL), have drawnmuch attention in recently years [1]–[4], due to the user-friendly syntax of formal languages and expressive powerfor describing complex task requirements. Temporal logictask planning algorithms can formally synthesize controland communication strategies for the robots by searchingon a constructed automaton that captures both the taskrequirements and robots’ capabilities.

This paper focuses on a common situation where eachrobot locally has its private individual LTL task specification,and all the robots also have to jointly satisfy a globalcollaborative LTL task specification. The completion of eachcollaborative task may require several robots of differenttypes. Prior studies of multi-robot task coordination underlocal temporal tasks usually assume that the collaborationrequirements are integrated into local task specifications,i.e., assignments of collaborative tasks are fully or partiallyknown in prior. The execution plans are typically synthesizedoffline and then executed online by the robots while alsoreacting to environment changes. However, little attentionhas been paid to reduce the waiting time for the robotsin each collaboration to improve the efficiency of actualexecution. Additionally, the concern of preserving individual

The authors are with the 1College of Electrical Engineering and2State Key Laboratory of Industrial Control Technology, Zhejiang Uni-versity, Hangzhou, 310027, China {brf, rzheng, liumeiqin,slzhang}@zju.edu.cn† Corresponding author

robots’ privacy also makes it difficult to optimize the overallperformance of the execution plans.

To mitigate the above issues, we propose a hierarchicalmulti-robot temporal task planning framework to synthesizecorrect and optimized task execution plans for the robots. Thehierarchical framework involves a central server to conductthe task allocation procedure; and then the robots implementthe planning and optimization procedures in a decentralizedmanner. Note that we do not assume the allocation of thecollaborative tasks are known in prior. Furthermore, to reducethe waiting time in collaborations for the robots, we proposean execution plan adjusting mechanism, in which the robotscan iteratively modify their execution plans to improve theexpected actual performance via inter-agent communication,while also preserving the private information about robots’individual tasks. The contributions of the paper are summa-rized as follows:

1) we propose a hierarchical multi-robot temporal taskplanning framework to efficiently synthesize executionplans for the robots satisfying both individual andglobal collaborative LTL task specifications, withoutassuming that assignments of collaborative tasks areexplicitly given;

2) Moreover, we propose an execution plan adjustingmechanism, in which the robots can iteratively modifytheir execution plans to improve the expected executionperformance via inter-agent communication, while alsopreserving the private information about individualtasks;

3) we analyze the complexity and non-optimality of theproposed method. Extensive simulation experimentsverify the correctness and efficiency of the proposedmethod.

A. Related Works

Existing studies in multi-robot task planning under tem-poral logic constraints fall into two categories: the top-downand the bottom-up pattern. Studies in top-down pattern usu-ally assume a globally given temporal logic specification fora team of robots [5], and search for a path on a constructedproduct automaton that combines all robots’ environmentmodels and an automaton corresponding to the LTL formula.Several approaches have been proposed to improve thescalability of the traditional method, such as redundant statespruning [4], [6]; sampling-based searching [7]–[9]; and thedecomposition of task specification [10], [11], etc.

More related to this paper, studies in bottom-up patterntypically distribute the task specification to individual robots.

©2021 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, includingreprinting/ republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists,or reuse of any copyrighted component of this work in other works.

arX

iv:2

108.

1159

7v2

[cs

.RO

] 2

7 A

ug 2

021

M. Guo et al. [12] investigated the task coordination ofloosely coupled multi-agent systems with dependent localtasks. The robots synthesize an off-line initial plan inde-pendently, and then execute the collaborative actions onlinewith the assistance of other robots after the request-replymessage exchanging and computation. The above methodis further modified in [13] to permit heterogeneous ca-pabilities of robots and include an online task swappingmechanism. J. Tumova et al. [14] considered a slightlydifferent setting from [12], in which each robot have its localcomplex temporal logic specifications, including an inde-pendent motion specification; and a dependent collaborativetask specification. An two-phase automata-based method wasproposed, where each robot synthesizes its motion planningon a local automaton; then a centralized planning procedureis conducted on a product automaton of the pruned localautomaton where only states related to the collaborative tasksare left. Despite the size of the product automaton have beengreatly reduced by the pruning techniques, the method stillhas exponential complexity.

Y. Kantaros et al. [15] analyzed a similar situation tothis paper, that robots have their independent individualtask specifications, while they have to jointly satisfy theglobal intermittent communication tasks, that require severalrobots to intermittently gather in some locations to exchangeinformation. The paper proposes an algorithm in which therobots iteratively optimize their gathering locations to reducethe total traveling distance via on-line communication.

Inspired by [15], we extend the global collaborative taskspecification into finite LTL; and aim to minimize the totaltime spent to finish all tasks considering reducing the waitingtime for the robots in each collaboration, which has not beenconsidered in [15]. Furthermore, the planning and optimiza-tion procedures are all performed in decentralized manner, sothat robots’ private information about their individual taskscan be preserved.

II. PRELIMINARIES AND PROBLEM FORMULATION

A. Linear Temporal Logic

An LTL formula ϕ over a set AP of atom propositions aredefined according to the following recursive grammar [16]:

ϕ ::= true | π | ϕ1 ∧ ϕ2 | ¬ϕ | © ϕ | ϕ1Uϕ2,

where true is a predicate true and π ∈ AP is an atomproposition. The other two frequently used temporal oper-ators 3 (eventually) and 2 (always) can be derived fromoperator U (until). In this paper, we only consider a kind offinite LTL [17] called LTLf , which is a variant of originalLTL that can be interpreted over finite sequences, and usesthe same syntax as original LTL. Moreover, we exclude the© (next) operator from the syntax, since it is not meaningfulin practical applications [18]. We refer the reader to [16] forthe details of LTL semantics.

Given an LTLf formula ϕ, a nondeterministic finite au-tomaton (NFA) can be constructed which accepts exactly thesequences that make ϕ true.

ϕ1 = (3πts1 ) ∧ (3πts2 ) ∧ (3πts3 )∧(3πts4 ) ∧ (¬πts1 U πts4 )

ϕ2 = · · ·. . .

φ = (3πct1 ) ∧ (3πct2 ) ∧ (3πct4 )∧(¬πct3 U πct2 )∧(2(πct4 → (3πct3 )))

robot i ts ∈ Ti ct ∈ T

Fig. 1. The simulation results of an experiment with 3 robot.

Definition 1 (Nondeterministic Finite Automaton). A non-deterministic finite automaton (NFA) F is a tuple F :=〈QF ,Q0

F , α, δ,QFF 〉, where QF is a finite set of states;Q0F ⊆ QF is a set of initial states; α is a set of Boolean

formulas over π ∈ AP; δ : QF ×QF → α is the transitioncondition of states in QF ; QFF is a set of accepting states.

A finite sequence of states qF ∈ QF is called a runρF . A run ρF is accepting if it starts from one initial stateq0F ∈ Q0

F and ends at an accepting state qFF ∈ QFF . Givena finite sequence σ = σ(1)σ(2) . . . σ(L − 1)σ(L), we saythat σ describes a run ρF if σ(i) � δ (ρF (i), ρF (i+ 1)) forall i ∈ [1 : L− 1], i.e., σ(i) is a set of atom propositionsor negative propositions, which makes the Boolean formulaδ (ρF (i), ρF (i+ 1)) become true. Here [1 : L− 1] denotesa set of indexes increasing from 1 to L−1 by step 1. A finitesequence σ fulfills an LTLf formula if at least one of its runsis accepting. The minimum requirements for a sequence todescribe a run can be represented as an essential sequence,as in the following definition.

Definition 2 (Essential Sequence). Considering a sequenceσ = σ(1) . . . σ(L), it is called essential if and only if it de-scribes a run ρF in NFA F and σ(i)\{π} 2 δ(ρF (i), ρF (i+1)) for all π ∈ σ(i) and i ∈ [1 : L− 1].

B. System Model

Consider there is a set of robotsN := {1, ..., N} operatingin an environment, e.g., as in Fig. 1, which can be representedas a graph W = 〈Q, E〉. Here Q is the set of regions ofinterest and E contains the connectivity relations of regionsin Q. Each robot i ∈ N has its specific capability cj ∈ Capand can provide service cj in the environment W . The setCap := {cj}j∈{1,...,|Cap|} contains all capability types. Wedefine Nj := {i |robot i has the capability cj}.

There are several tasks distributed in W to be completedby the robots, as defined in Definition 3.

Definition 3 (Task Requirement). A task in W is a tuplets := 〈πts, {(cj ,mts

j )}j∈Its , qts〉, where πts is the uniqueatom proposition of ts; qts ∈ Q corresponds to the regionassociated with ts; and ts can be completed, i.e, πts becomestrue, if at least mts

j robots with capability cj are deployedsimultaneously for all j ∈ Its and perform actions according

to their capabilities, where Its ⊆ {1, ..., |Cap|} containsindexes of capabilities required by ts.

In this paper, we consider the situation that: (1) eachrobot i ∈ N has a pre-assigned private individual taskspecifications ϕi that can be satisfied by itself. Here ϕiis an LTLf formula defined over Ti, which is robot i’sindividual task set. For each ts ∈ Ti, it holds that |Its| = 1,mtsj = 1, and i ∈ Nj ; (2) the robots have to jointly satisfy

a global LTLf task specification φ defined over a set T oftasks, in which each task ct ∈ T may has much heavierworkloads and requires no less than one robot with severaldifferent capabilities. Note that we particularly use ct torepresent a task in T, called collaborative task, to distinguishit from tasks in the set

⋃i∈N Ti of all individual tasks in

the following context.We assume that the execution of each individual task

specification ϕi is independent of each other, i.e., doesnot influence the states of other robots. And they are alsoindependent of the execution of collaborative tasks. Moreformally, we assume that: ∀ i, j ∈ N and i 6= j, Ti ∩Tj = ∅; and ∀ i ∈ N , T ∩ Ti = ∅. Otherwise, the non-independent task requirements can be formulated into theglobal collaborative task specification φ.

The mobility and capability of each robot i can be for-malized as a weighted transition system.

Definition 4 (Weighted Transition System). A weightedtransition system of robot i is a tuple wTSi = 〈Qi, q0i ,→i, ωi,APi, Li〉, where Qi ⊆ Q is a finite set of statescorresponding to regions inW; q0i is the initial state;→i⊆ Econtains all pairs of adjacent states; ωi : Qi×Qi → R+ is aweight function measuring the cost for each transition; APiis the set of atom propositions related to the tasks in W;Li : Qi → 2APi is a labeling function, and satisfies that (1)∀ ts ∈ Ti, πts ∈ Li(qts); (2) ∀ ct ∈ T, πct ∈ Li(qct) iff∃j ∈ Ict, i ∈ Nj . Here qts, qct ∈ Qi are the states related tothe individual task ts and collaborative task ct respectively.

C. Problem Formulation

Let T colla denotes the total time cost for all robots tosatisfy all task requirements. T colla =

∑i∈N T

collai , where

T collai denotes the amount of time robot i spends to executeτi, considering the wait time in each collaboration (due tothe different arrival times of the robots in the collaboration).

Problem 1. Consider a set N of robots operate in anenvironmentW , and suppose that the mobility and capabilityof each robot i is modeled as a weighted transition systemwTSi. Given individual LTLf task specification ϕi for eachrobot i and a global collaborative task specification φ, findtask execution plan τi in wTSi for each robot i whichsatisfies:

1) the execution of τi satisfies individual task specifica-tion ϕi;

2) the joint behaviors of all robots satisfies collaborativetask specification φ;

3) the total time cost T colla is minimized.

SequenceSelection

Z3 SMT solver

f ← f ∧ ¬X

TaskAllocation

LocalPlanning

Execution PlanAdjusting

Robot 1: P1

Robot 2: P2

Robot ...

X

NFA F of φ

C(ctkl )

C(ctk′l′ )

Fig. 2. Framework of multi-robot temporal task planning.

III. MULTI-ROBOT TEMPORAL TASK PLANNING

In this section, we propose the multi-robot temporaltask planning framework to solve Problem 1, as shown inFig. 2. The proposed framework firstly finds a sequenceof collaborative tasks which satisfies the collaborative taskspecification and allocates the tasks in the sequence to robots.Then each robot locally synthesizes its initial task executionplan which satisfies the individual task specification andthe assigned collaborative tasks requirements. The initiallyobtained execution plans will be further improved by aproposed execution plan adjusting mechanism, which will beexplained in Sect. IV. The detailed steps of the frameworkare described in Alg. 1.

A. Selection and Decomposition of Execution Sequence

To find a collaborative task sequence satisfying the collab-orative task specification φ, a three-step scheme is developed:

1) prune the NFA F of φ by removing all impossibletransitions that require assistance beyond what therobot set N can provide.

2) identify the decomposition states in the pruned F byutilizing the decomposition algorithm proposed in [10].

3) select an essential sequence which describes an ac-cepting run in F , and divide it into independentsubsequences by the decomposition states along therun.

The way to prune F is straightforward and we omit thedetails here. The essential sequence σ that describes anaccepting run ρF in the pruned NFA F is actually a col-laborative task sequence that satisfies φ. Given an acceptingrun ρF of F and its corresponding essential sequence σ,the decomposition states along the run ρF can decomposeσ into S (≥ 1) subsequences, i.e., σ = σ1;σ2; . . . ;σS . LetS := [1 : S] denote the set of indexes. Such decompositionis proved to have two properties in [11]: (1) Independence.Execution of each subsequence σk will not violate anotherσj , ∀ k, j ∈ S and k 6= j; (2) Completeness. The completionof all subsequences σk implies the completion of σ. Thedetailed definition of decomposition states can be found inDefinition 9 and Theorem 2 of [10].

We define σk(m) := {ctk(m,j)}j∈[1:|σk(m)|] to denote them-th element in σk, in which ctk(m,j) ∈ T denotes the j-th task in the m-th element of σk. For notation simplicity,we use ct and πct interchangeably afterward. Note that weonly consider the positive atom propositions in the essential

sequence σ, and assume that the negative propositions areguaranteed in actual execution as safety guards, which mayimpose implicit communications in actual deployment.

The execution of collaborative tasks within each σk mustsatisfy the following temporal constraints according to theaccepting condition of F .• Synchronization Constraints. ∀ ctk(m,j), ct

k(m,j′) ∈

σk(m), j 6= j′, ctk(m,j) and ctk(m,j′) need to be executedsynchronously;

• Ordering Constraints. ∀ ctk(m,j), ctk(m′,j′) ∈ σ

k,m <

m′, ctk(m′,j′) cannot be executed before ctk(m,j).The above decomposition of essential sequence relaxes

the temporal constraints between the tasks in the essentialsequence, which may help to reduce the unnecessary commu-nication as well as the total time cost in actual deployment.

The selection of the collaborative task sequence σ hasimplicit influences on the performance of the final results.To reduce the complexity, in the sequel we just selectthe essential sequence σ that describes one of the shortestaccepting run ρF in the pruned F to be the collaborativetask sequence. Simulation results illustrate that the proposedmethod can find solutions of high quality in practice underthe selected σ.

B. SMT-Based Collaborative Task Allocation

After obtaining the decomposed collaborative task se-quence σ = σ1;σ2; . . . ;σS and the related accepting runρF of F , we now consider the allocation of collaborativetasks in the sequence σ.

For notation simplicity, we give all ctk(m,j) ∈ σk an index

l, defined as ctkl := ctk(m,j), where l =∑m−1i=1 |σk(i)| +

j, ∀ m ∈[1 : |σk|

]and k ∈ S. Then the l-th task in σk

can be referred as ctkl . We define a set of Boolean variablesXi := {x(k,l)i |ctkl ∈ σk, k ∈ S} for each robot i to indicatethe task assignment results. A true x(k,l)i implies that roboti is assigned to complete the task ctkl . Now we constructthe SMT (Satisfiability Modulo Theories) model of the taskallocation problem.

(1) Collaboration Requirements. A feasible task assign-ment must satisfy the amount and types of assistance neededto complete each collaborative task, as the following con-straints: for each σk, ∀ ctkl ∈ σk,∑

i∈N1(x(k,l)i

∧i ∈ Nj

)≥ mct

j ,∀j ∈ Ict

is satisfiable, where 1(·) is an indicator function defined as1(true) = 1 and 1(false) = 0.

(2) At Most One at a Time. Each robot cannot partici-pate in two distinct collaborative tasks which are executedsynchronously. The constraints can be captured by: for eachσk, ∀ ctkl1 , ct

kl2∈ σk(m), l1 6= l2,

¬x(k,l1)i

∨¬x(k,l2)i ,∀ i ∈ N

is satisfiable.(3) Communication Reduction. The intersection of two

sets of robots that complete two consecutive collaborative

tasks is not empty: for each σk,∨i∈N

(∨l∈{lkm−1+1,...,lkm}x

(k,l)i

∧∨l∈{lkm+1,...,lkm+1}x

(k,l)i

)is satisfiable, where lkm =

∑mj=1 |σk(j)|, ∀m ∈ [1 : |σk|−1].

When the communication is limited in the environment,the above constraints (3) can be applied to guarantee thateach robot i only needs to communicate with its assistantrobots j ∈ R(ct)\{i} when executing the assigned collabo-rative task ct. The function R : ctkl → 2N maps ctkl to a setof robots that perform the task. The constraint (3) requiresthat R(σk(m))

⋂R(σk(m+ 1)) 6= ∅, ∀ m ∈

[1 : |σk| − 1

].

The robot i ∈ R(σk(m))⋂R(σk(m + 1)) behaves like

a coordinator to guarantee the execution order of tasks inσk(m) and σk(m + 1). Here the function R is reloaded asR(σk(m)) =

⋃ct∈σk(m)R(ct) according to SMT constraint

(2) and the synchronization constraints in Sect. III-A.

Remark 1. The SMT constraints (3) can be selectivelyapplied to some pairs of consecutive collaborative tasks,whose locations may be far apart so that it is difficult toensure the connectivity of the communication links betweenthese regions.

The overall SMT formula f is a conjunction of allBoolean expressions of the above constraints (1) (2) (3). Wedefine X =

∧i∈N

(∧x(k,l)i ∈Xi

x(k,l)i

)as the Boolean formula

corresponds to a feasible task assignment {Xi}i∈N whichsatisfies f . By utilizing an SMT solver, we can iterate allvalid assignments by adding the negation of current X intof , i.e., f = f ∧ ¬X (Line 13 of Alg. 1). Each feasible taskassignment {Xi}i∈N will be passed into the subsequent localplanning procedure to further investigate its performance.

Here we come up with a filtering strategy to fast filter thenon-optimal task assignments. The efficiency of the filteringstrategy will be evaluated in Sect. V.

Filtering Strategy: If ∃ m < n and m,n ∈ N+, suchthat ∀i ∈ N , Xni ≥ Xmi , then f can be directly modifiedas f ∧ ¬Xn without proceeding the subsequent procedures,where Xmi , Xni are the feasible task assignments for roboti in m-th and n-th iterations, respectively. Here Xni ≥ Xmimeans that ∀ nx(k,l)i ∈ Xni and mx

(k,l)i ∈ Xmi , 1(nx

(k,l)i ) ≥

1(mx(k,l)i ).

Given the obtained task assignment results, each robotwill combine the assigned collaborative tasks with its localtask specification to synthesize its initial execution plan. Thedetails will be discussed in the next subsection.

C. Execution Plan Synthesis With Collaborative Tasks

To synthesize the individual task execution plan for eachrobot, the key problem is how to construct a local LTLfformula that captures the individual task specification ϕi, aswell as the temporal constraints of the assigned collaborationtasks.

Given one feasible task assignments X , we construct setTki :=

{ctkl

∣∣ x(k,l)i is true}

for all k and i. Let Ti :=

⋃k∈S Tki . We sort all tasks in Ti in the increasing order

of indexes k and l.The modified local LTLf formula ϕi for each robot i is

the conjunction of ϕi and φi, i.e., ϕi = ϕi∧φi. Here φi

is the LTLf formula that captures the requirements of tasksct ∈ Ti. There are two steps to construct φi and ϕi:

Step 1: Formalize ordering constraints within each in-dependent subsequence. We initialize the collaborative taskspecification φki corresponds to Tki as φki = 3(ctkl1),where ctkl1 is the first task in the sorted Tki . Then we usectklm

∧3(ctklm+1

) to iteratively substitute ctklm in φki , wherectklm and ctklm+1

are two consecutive tasks in sorted Tki , andlm < lm+1.

The asynchronous execution of several independent subse-quences may stick into deadlock in actual deployment, due tothe different execution order in each robot’s local executionplan. We use Step 2 to prevent the deadlock.

Step 2: Determine the execution order of each independentsubsequence. For each robot i, we sort φki in Step 1 inincreasing order of index k, ∀ k ∈ S. Starting from k = 1 toS − 1, we iteratively replace ctklmax with ctklmax

∧3(φk+1

i ),where ctklmax is the last collaborative task in sorted Tki .Finally, φi = φ1i , and ϕi = ϕi

∧φi.

Given the wTSi and Fi of ϕi, each robot i can find itsinitial individual optimal run ρi by searching for the shortestaccepting run on a product automaton Pi, as defined inDefinition 5. The initial task execution plan τi of robot ican be obtained by projecting the run ρi into the state spaceof wTSi, i.e., τi = Πiρi.

Definition 5 (Product Automaton). The product automatonof wTSi and Fi is a tuple Pi = wTSi⊗Fi = 〈QP ,Q0

P ,→P

, ωP ,QFP 〉, where QP = Qi ×QF ; Q0P = q0i ×Q0

F ; →P⊆QP ×QP , which satisfies that ∀ (qP , q

′P ) ∈→P , it holds that

(ΠiqP ,Πiq′P ) ∈→i and Li(ΠiqP ) � δ(ΠF qP ,ΠF q

′P ). Here

Πi and ΠF represent the projections into the state spaces ofwTSi and Fi, respectively; ωP (qP , q

′P ) = ωi(ΠiqP ,Πiq

′P );

QFP ⊆ Qi ×QFF .

In actual execution, the time instances when robots takepart in each collaboration may be different, since robotssynthesize their task execution plans independently withoutconsidering others. In the next section, the initial task exe-cution plans will be optimized.

IV. GREEDY-BASED EXECUTION PLAN ADJUSTMENT

In this section, we propose a greedy-based execution planadjusting mechanism that can reduce the waiting time incollaborations (due to the different arrival times of robots ineach collaboration) to optimize the total time cost. We definethe collaborative state to identify the states in Pi related tothe execution of collaborative tasks ctkl ∈ Ti:

Definition 6 (Collaborative State). For ∀ qP ∈ QP , qP ∈C(ctkl ) iff the following two conditions hold. Here C(ctkl ) isa set of all collaborative states of collaborative task ctkl .

1) ctkl ∈ Li(ΠiqP );2) ∃q′P ∈ QP , qP ∈ δ(q′P , ctkl ), and ΠFq

′P 6= ΠFqP .

Algorithm 1: FrameworkInput : {ϕi}i∈N , φ, WOutput : {τi}i∈N

1 Construct wTSi for i ∈ N .2 Convert φ to its corresponding NFA F .3 Prune F and identify the decomposition states in F . Select

and decompose the collaborative task execution sequenceσ = σ1;σ2; . . . ;σS of an accepting run ρF in F .

4 Construct the SMT-based task allocation model f .5 while SAT(f) do6 X ← SMT-solver(f)7 for i ∈ N do8 φi ← the LTLf formula captures the assigned

ct ∈ Ti and the temporal constraints9 ϕi ← ϕi

∧φi // according to X

10 Pi ← wTSi

⊗Fi // Fi is the NFA of ϕi

11 ρi ← local optimal path of Pi

12 ExecutionPlanAdjusting ({Pi}i∈N , {ρi}i∈N )13 f ← f

∧¬X

14 return τi ← Πiρi for each robot i ∈ N .

Algorithm 2: TimeCost1 delayi = 0, for i ∈ N .2 for ct ∈ Tsort do3 t(ct) = maxi∈R(ct){ti(ct) + delayi}4 for i ∈ R(ct) do5 delayi = t(ct)− ti(ct)

6 T collai = T indiv

i + delayi, for i ∈ N .7 return T colla =

∑i∈N T

collai

The condition 2) ensures that the robot plans to performtask ctkl at state qP rather than just going through it.

A. Total Time Cost Considering Collaboration

The total time cost to finish all tasks can be calculatedby Alg. 2. We define Tsort = {σk(m)}∀m∈[1:|σk|],k∈S , inwhich all elements of Tsort are sorted in increasing orderof indexes k and m. In fact, it holds that |Tsort| = |σ|.Each element σk(m) ∈ Tsort can be treated as a general-ized collaborative task since all tasks in the same σk(m)have the same execution time, according to synchronizationconstraints in Sect. III-A. The variable delayi in Alg. 2denotes the total wait time for robot i up to the execution ofcurrent ctkl and is modified after each collaboration. Giveninitial optimal run {ρi}i∈N , if there is no waiting time inprevious collaborations, i.e., delayi = 0, then the time roboti arrives at the region of task ctkl can be calculated byti(ct

kl ) =

∑jkl −1j=1 ωi(ρi(j), ρi(j + 1)), ∀ ctkl ∈ Ti. Here

jkl denote the index of state q in ρi that satisfies q = ρi(jkl )

and q ∈ C(ctkl ), for all ctkl ∈ Ti. The ti(·) with subscripti denotes that it is the ideal arrival time from robot i’sperspective without considering the possible waiting time ineach collaboration.

Let t(ct) denote the actual execution time of task ct, whichis determined by the actual arrival time of the latest robot i,i.e., t(ct) = maxi∈R(ct) {ti(ct) + delayi} (Line 3, Alg. 2).

Note we reload the definition of ti(·) as ti(σk(m)) = ti(ctkl ),

∀ ctkl ∈ σk(m) ∩ Ti.The total time cost to complete all task execution plans can

be calculated by T colla =∑i∈N T

collai =

∑i∈N (T indiv

i +

delayi), where T indivi =

∑|ρi|−1j=1 ωi (ρi(j), ρi(j + 1)), and

delayi is the total waiting time in all collaborations of ctkl ∈Ti. The variable delayi may increase in each collaborationbecause each robot i does not consider the collaboration withothers in the local planning procedure.

B. Greedy-based Execution Plan Adjusting

The proposed execution plan adjusting mechanism (Alg. 3)tries to reduce the wait time in each collaboration, andsequentially traverses all collaborative task ct ∈ Tsort ac-cording to their execution order, and performs the followingtwo steps:

Step 1: The robots in R(ct) find the latest robot i toarrive at the region of ct by inter-robot communication; andthen the robot i investigates whether T colla can be decreasedby adjusting its pre-planned execution time of task ct to anearlier time, to reduce the wait time of other robots in R(ct)(Lines 4-6).

Step 2: If Step 1 fails, the robots then select the earliestrobot i to execute task ct in this step instead of the latest;and the robot i tries to postpone the planned execution timeti(ct) to reduce the wait time for itself.

If no optimization happens in one iteration, i.e., count =0, then Alg. 3 will terminate (Lines 14-15). Otherwise,count > 0 means the modified task execution plan results ina smaller T colla (Lines 7-8, 12-13), and the algorithm willgo on to the next iteration to further optimize current plans.

Note that the robots only need to exchange informationabout when to task part in each collaborative tasks, sothat their private information about individual tasks can bepreserved.

The detailed adjusting strategy is explained in FunctionOptTime of Alg. 3. For the selected latest (or the earliest)arrival robot i in the collaboration of task ctkl ∈ Ti, theset C(ctkl ) of Pi actually provides all candidates states thatcan execute ctkl , namely, all possible arrival time to ctkl . Therobot i randomly traverses all state q ∈ C(ctkl )\{ρi(jkl )}until finding one candidate state q which can optimize T colla.For each candidate state q, the robot i searches a candidaterun ρ′

iin Pi. The candidate run ρ′

ikeeps ρi[..j

prev − 1]unchanged, but finds subsequent sequence from ρi(j

prev) tothe accepting states of Pi, forcing it to pass through q (Line20). Here ρi(j

prev) is the collaborative state of task ctprev

in ρi and ctprev is the previous collaborative task of ctkl inTi. The candidate run ρ′

iis selected to be the new ρi if the

following two conditions hold (Lines 21-25):

1) if robot i is the latest robot, it holds that t(ctprev) −ti(ct

prev) + t′i(ctkl ) < ti(ct

kl );

if robot i is the earliest robot, it holds that ti(ctkl ) <t(ctprev)− ti(ctprev) + t′i(ct

kl ) ≤ t(ctkl ).

2) T collacand < T colla.

Algorithm 3: ExecutionPlanAdjustingInput : {Pi}i∈N , {ρi}i∈N

1 while true do2 count← 03 for ct ∈ Tsort do4 ctprev ← the previous task of ctkl in Ti.5 i← arg max

i∈R(ct)

{t(ctprev)− ti(ctprev) + ti(ct

kl )}

6 can opt← OptTime(Pi, ct

kl , ρi, isMax = true

)7 if can opt then8 count← count+ 19 else

10 i← arg mini∈R(ct)

{t(ctprev)−ti(ctprev)+ti(ct)}

11 can opt← OptTime(Pi, ct

kl , ρi, false

)12 if can opt then13 count← count+ 1

14 if count = 0 then15 break

16

17 Function OptTime(Pi, ctkl , ρi, isMax):

18 ctprev ← the previous task of ctkl in Ti.19 for q ∈ C(ct)\{ρi(j

kl )} do

20 ρ′i← ρi[..j

prev − 1]+Dijkstra(Pi, ρi(j

prev), q)+Dijkstra(Pi, q,Q

FP )

21 if(isMax

∧t(ctprev)− ti(ctprev) + t′i(ct

kl ) < ti(ct

kl ))

or ((isMax = false)∧

ti(ctkl ) < t(ctprev)− ti(ctprev) + t′i(ct

kl ) ≤ t(ctkl )

)then

22 T collacand ← TimeCost(ρ′

i)

23 if T collacand < T colla then

24 ρi ← ρ′i

25 return true

26 return false

The condition 1) ensures that in the candidate run ρ′i, the

time when the latest robot i arrives ctkl is advanced (ordelayed for the earliest robot), such that the waiting timein the collaboration of task ctkl is reduced. Here t′i(ct

kl ) is

calculated according to the candidate run ρ′i. The condition

2) further guarantees the above local greedily adjustmentprocedure will also contribute to the total time cost T colla.If the algorithm cannot find a qualified candidate run ρ′

ithat

satisfies the above two conditions, then returns false.

C. Monotonicity, Complexity, and Optimality

Proposition 1. Algorithm 3 is monotonic and terminateswithin finite iterations.

Proof. Given the collaborative task assignments, T colla

monotonically decreases from T collainit to T indiv, because

it decreases to a strictly smaller T collacand in each iteration

(Lines 22-25, Alg. 3) until the algorithm terminates. HereT indiv =

∑i∈N T

indivi , and T colla

init is the time cost of initialexecution plans for robots in N . Considering the resolutionof discretization of the environment is limited, we concludethat Algorithm 3 will terminate within finite iterations. �

Proposition 2. The worst case time complexity of Algo-rithm 3 is O

((T colla

init − T indiv) · |Pi| · (E · lgE + |σ| ·N)),

where N is the number of robots, |Pi| and E are themaximum number of states and edges in all Pi respectively.|σ| is the length the selected accepting run in Sect. III-A.

Proof. In the worst case, Alg. 3 will traverse all candidatecollaborative states in Pi in each cycle of the while loop(Lines 1-15). The number of cycles of the while loop is lim-ited by O(T colla

init −T indiv) as in Proposition 1. For each can-didate collaborative state, the function OptTime utilizes Di-jkstra algorithm to find a run ρ′i with complexity O(E ·lgE),and also calls Alg. 2 to validate the candidate run with timecomplexity |σ| · N . To summarize, the time complexity ofAlg. 3 is O

((T colla

init − T indiv) · |Pi| · (E · lgE + |σ| ·N)).�

Optimality: The proposed framework does not guaranteeto obtain the optimal execution plans, because Algorithm 3utilizes a greedy strategy rather than exhaustively investi-gating the combinations of all possible feasible executionplans. Given assignments of collaborative tasks, a dynamicprogramming method can be used to find the optimal execu-tion plans for the robots, but it has exponential complexityin each step. Moreover, the choice of the selection ofcollaborative task sequence σ in Sect. III-A also influencesthe performance of the final results.

V. SIMULATION RESULTS

In this section, we evaluate the scalability of the proposedframework comparing with a baseline method based onglobal product automaton, and showcase the effectivenessof the proposed execution plan adjusting mechanism inreducing the total time cost to finish all tasks. All theexperiments are performed on a Ubuntu 16.04 server withCPU Intel Xeon E5-2660 and 128 GB of RAM. We useZ3 [19] SMT solver to solve the SMT model in the taskallocation procedure.

We assume a grid map environment where individual tasksand collaborative tasks are randomly distributed. Each roboti has a local task specification ϕi, e.g., ϕi = (3πts1) ∧(3πts2)∧(3πts3)∧(3πts4)∧(¬πts1 U πts4). Additionally,the team of robots needs to collaborate to satisfy collabo-rative task specification φ, e.g., φ = (3πct1) ∧ (3πct2) ∧(3πct4) ∧ (¬πct3 U πct2) ∧ (3(πct4 ∧ (3πct3))) , whereeach ct ∈ T requires collaboration of several types of robotshaving capabilities from {c1, c2, c3}. The type and amountof robots needed for each collaborative task are randomlygenerated in the experiments. The final execution plans inan experiment with 3 robots are depicted in Fig. 1.

(1) Scalability and Efficiency. To evaluate the scalabilityof the proposed method, we compare the proposed methodwith a baseline method based on the product automatondenoted by P with state pruning techniques, whose construc-tion process is similar to [14]. The details are omitted heredue to space limitations.

We investigate the performance of the two methods indifferent environment sizes and robot numbers, as shown

TABLE IBASELINE METHOD (B.S.) VS THE PROPOSED METHOD (PROPOSED)

Env. N |P| B.S. Proposed SpeedSize (sec/sec) (sec/sec) Up

5× 52 2.22× 103 30/0.58 30/0.11 53 7.17× 104 57/84.62 51/0.94 905 8.20× 107 -/- 59/7.91 -

10× 102 4.08× 104 40/16.15 39/0.56 293 4.13× 106 78/104571 78/3.57 292925 4.87× 1010 -/- 148/32.00 -

15× 152 2.04× 105 88/117.42 78/1.23 953 4.80× 107 -/- 145/8.45 -5 2.52× 1012 -/- 163/102.60 -

The items in column B.S. and Proposed represent: T colla/tcal, whereT colla is the total time cost to satisfy all task specifications and tcal is thesolving time. The “-” items indicate memory overflow.

5 10 15 20 25 30

0.400.500.600.700.800.901.001.101.20

20 × 2030 × 3040 × 40

5 10 15 20 25 30

1.101.201.301.401.501.601.701.801.90

20 × 2030 × 3040 × 40

Tcolla/T

colla

init

tcal/tc

al−

adj

N N(a) (b)

Fig. 3. The comparison of the framework with the execution plan adjustingmechanism versus without it: (a) T colla/T colla

init ; (b) tcal/tcal−adj.

in Table I. The proposed method quickly solves all thecases and is much faster in comparison with the baselinemethod. The total time cost of the solutions provided by theproposed method is better than that of the baseline method,since there is no efficient way to find the optimal run w.r.tthe total time cost (which takes into account the wait timein each collaboration) in the product automaton P . Theresults illustrate that the proposed method can provide high-quality solutions to Problem 1, and also has high scalabilitycomparing with the baseline method.

(2) Optimization Performance. To investigate the opti-mization performance of the execution plan adjusting mech-anism (Alg. 3), we conduct extensive simulations undervarious numbers of the robots and environment sizes. Thenumber of robots varies from {5, 10, 15, 20, 25, 30} and threetypes of environment sizes are investigated. In each setting,we randomly distribute the tasks in the grid map environmentfor 10 independent trials under the same task specifications.We terminate the solving process when the running timeexceeds 30 minutes, and choose the best result up to theend time. As shown in Fig. 3, the proposed execution planadjusting mechanism can reduce T colla to about 70% ∼ 80%of its initial value T colla

init , while tcal, the running time of theframework with the execution plan adjusting mechanism, is1.x-proportional to tcal−adj the running time of the proposedframework without the execution plan adjusting procedure.This indicates that the proposed adjusting mechanism cantrade a small increase of running time for a large im-

0 20 40 60 80 100 120

1000

2000

3000

4000

5000

6000

Tcolla

initTcolla

T indiv

0 20 40 60 80 100 120

0

50

100

150

200

250

300

350

Recorded Filtered Sum of filtered

Iterations Iterations

Tota

ltim

eco

st

Num

ber

ofso

lutio

ns

(a) (b)

Fig. 4. (a) The optimization process of the total time cost and (b) thefiltered SMT solutions in each iteration by utilizing the filtering strategy inan experiment with 30 robots.

provement of performance, and the conclusion holds underdifferent sizes of robot teams. We have attached a video toillustrate the improvement of the obtained execution planscaused by the proposed adjusting mechanism.

As shown in Fig. 4(a), the total time cost T colla afteroptimization is approaching T indiv after execution plan ad-justing procedure in each iteration, i.e., under each taskassignment scheme, in an experiment with 30 robots ina 20 × 20 grid map. It illustrates that the execution planadjusting mechanism can greatly optimize the initial taskexecution plans in each iteration. Note that T indiv is notthe lower bound of the optimal solution to Problem 1. Inaddition, as shown in Fig. 4(b), by utilizing the filteringstrategy proposed in Sect. III-B, many obtained feasiblesolutions of the task assignment problem can be filteredto prevent unnecessary computation in the same experimentas in Fig. 4(a). The strategy only needs to maintain a setof solutions with its size propositional to the number ofiterations, Note that the filtering efficiency depends on theinner computation mechanism of the SMT solver and thespecific task requirements.

VI. CONCLUSIONS AND FUTURE WORK

We propose a hierarchical multi-robot temporal task plan-ning framework in which robots can efficiently synthesizeexecution plans that satisfy both individual and collaborativetemporal logic task specifications, while also protecting theirprivate information about individual tasks. The expectedactual performance of execution plans can be iterativelyimproved by reducing the waiting time for the robots in eachcollaboration, utilizing the proposed adjusting mechanism.Simulation results illustrate the correctness and efficiencyof the proposed method. Future work is to improve theefficiency of the task allocation procedure and expand thecurrent framework into complete LTL.

ACKNOWLEDGMENT

The work was supported by Natural Science Foundationof China under Grant 61873235, Zhejiang Provincial NaturalScience Foundation of China under Grant LZ19F030002, andthe NSFC-Zhejiang Joint Fund for the Integration of Indus-trialization and Informatization under Grant U1909206. Thiswork was also supported by the NSFC-Zhejiang Joint Fund

for the Integration of Industrialization and Informatizationunder Grants U1709203, U1809212 and the Key Researchand Development Program of Zhejiang Province under Grant2019C03109.

REFERENCES

[1] G. E. Fainekos, H. Kress-Gazit, and G. J. Pappas, “Temporal logicmotion planning for mobile robots,” in Proceedings of the 2005 IEEEInternational Conference on Robotics and Automation, pp. 2020–2025,2005.

[2] S. L. Smith, J. Tumova, C. Belta, and D. Rus, “Optimal path planningfor surveillance with temporal-logic constraints,” The InternationalJournal of Robotics Research, vol. 30, no. 14, pp. 1695–1708, 2011.

[3] E. Plaku and S. Karaman, “Motion planning with temporal-logicspecifications: Progress and challenges,” AI Communications, vol. 29,pp. 151–162, 08 2015.

[4] D. Khalidi, D. Gujarathi, and I. Saha, “T* : A heuristic searchbased path planning algorithm for temporal logic specifications,” inProceedings of the 2020 IEEE International Conference on Roboticsand Automation, pp. 8476–8482, 2020.

[5] A. Ulusoy, S. L. Smith, X. C. Ding, C. Belta, and D. Rus, “Optimalityand robustness in multi-robot path planning with temporal logicconstraints,” The International Journal of Robotics Research, vol. 32,no. 8, pp. 889–911, 2013.

[6] Y. Kantaros and M. M. Zavlanos, “Intermittent connectivity controlin mobile robot networks,” in Proceedings of the 2015 49th AsilomarConference on Signals, Systems and Computers, pp. 1125–1129, 2015.

[7] C. Ioan Vasile and C. Belta, “Sampling-Based Temporal Logic PathPlanning,” arXiv e-prints, p. arXiv:1307.7263, July 2013.

[8] Y. Kantaros and M. M. Zavlanos, “Sampling-based control synthesisfor multi-robot systems under global temporal specifications,” inProceedings of the 2017 ACM/IEEE 8th International Conference onCyber-Physical Systems, pp. 3–14, 2017.

[9] Y. Kantaros and M. M. Zavlanos, “Stylus*: A temporal logic optimalcontrol synthesis algorithm for large-scale multi-robot systems,” TheInternational Journal of Robotics Research, vol. 39, no. 7, pp. 812–836, 2020.

[10] P. Schillinger, M. Burger, and D. V. Dimarogonas, Decomposition ofFinite LTL Specifications for Efficient Multi-agent Planning, pp. 253–267. Cham: Springer International Publishing, 2018.

[11] P. Schillinger, M. Burger, and D. V. Dimarogonas, “Simultaneous taskallocation and planning for temporal logic goals in heterogeneousmulti-robot systems,” The International Journal of Robotics Research,vol. 37, no. 7, pp. 818–838, 2018.

[12] M. Guo and D. V. Dimarogonas, “Bottom-up motion and task coordi-nation for loosely-coupled multi-agent systems with dependent localtasks,” in Proceedings of the 2015 IEEE International Conference onAutomation Science and Engineering, pp. 348–355, 2015.

[13] M. Guo and D. V. Dimarogonas, “Task and motion coordination forheterogeneous multiagent systems with loosely coupled local tasks,”IEEE Transactions on Automation Science and Engineering, vol. 14,no. 2, pp. 797–808, 2017.

[14] J. Tumova and D. V. Dimarogonas, “Decomposition of multi-agentplanning under distributed motion and task ltl specifications,” inProceedings of the 2015 54th IEEE Conference on Decision andControl, pp. 7448–7453, 2015.

[15] Y. Kantaros, M. Guo, and M. M. Zavlanos, “Temporal logic task plan-ning and intermittent connectivity control of mobile robot networks,”IEEE Transactions on Automatic Control, vol. 64, no. 10, pp. 4105–4120, 2019.

[16] C. Baier and J.-P. Katoen, Principles of Model Checking (Represen-tation and Mind Series). The MIT Press, 2008.

[17] G. De Giacomo, R. De Masellis, and M. Montali, “Reasoning on LTLon finite traces: Insensitivity to infiniteness,” in Proceedings of the2014 28th AAAI Conference on Artificial Intelligence, p. 1027–1033,AAAI Press, 2014.

[18] M. Kloetzer and C. Belta, “A fully automated framework for control oflinear systems from temporal logic specifications,” IEEE Transactionson Automatic Control, vol. 53, no. 1, pp. 287–297, 2008.

[19] L. De Moura and N. Bjørner, “Z3: An efficient smt solver,” inProceedings of the Theory and Practice of Software, 2008 14thInternational Conference on Tools and Algorithms for the Constructionand Analysis of Systems, p. 337–340, Springer-Verlag, 2008.