University of Southern California Dissertations and Theses

Coalition formation for multi-robot systems

(USC Thesis Other)

Coalition formation for multi-robot systems

PDF

Download a page range

Download transcript

Copy asset link

Request this asset

Transcript (if available)

Content COALITION FORMATION FOR MULTI-ROBOT SYSTEMS
by
Charles Su
A Thesis Presented to the
FACULTY OF THE GRADUATE SCHOOL
UNIVERSITY OF SOUTHERN CALIFORNIA
In Partial Fulfillment of the
Requirements for the Degree
MASTER OF SCIENCE
(COMPUTER SCIENCE)
August 2007
Copyright 2007 Charles Su
Acknowledgments
I would like to foremost thank Sven Koenig for the amount of time and effort he spent to
understand and help me understand what I was doing. His help was a great inspiration
that played a major factor in getting me through.
Gaurav Sukhatme was a great professor and committee member. His courses were a
highlight of USC.
Thanks to Kristina Lerman for taking this on so late, while still being able to provide
valuable critique and insight.
Also I appreciate greatly Maja Mataric and Dylan Shell for their initial help with
finding and researching a topic.
Lastly I would like to thank my parents and my girlfriend Sandra for their support
and understanding during the last year.
ii
Table of Contents
Acknowledgments ii
List Of Tables v
List Of Figures vi
Abstract ix
Chapter 1: Introduction 1
1.1 Complex problem domains . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Chapter 2: Problem 5
2.1 Example problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Problem statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Related Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Chapter 3: Complex Domains 13
3.1 Intertask dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.1.1 Common dependencies . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.1.2 Implications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 Rich utility functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2.1 Implicit constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2.2 Implications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Chapter 4: Multi-Robot Task Allocation 20
4.1 Task decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2 Task Allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.4 Existing coalition formation algorithms. . . . . . . . . . . . . . . . . . . . 26
4.4.1 Shehory and Kraus’s algorithm . . . . . . . . . . . . . . . . . . . . 26
4.4.2 Vig and Adams algorithm . . . . . . . . . . . . . . . . . . . . . . . 28
4.4.3 Issues with applying previous work . . . . . . . . . . . . . . . . . . 29
4.5 Constraint satisfaction approach for moderately complex problems . . . . 30
4.5.1 Constraint Satisfaction MRTA Algorithm . . . . . . . . . . . . . . 33
4.5.2 Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
iii
4.6 High complexity MRTA problems . . . . . . . . . . . . . . . . . . . . . . . 35
4.6.1 Problem-specific heuristics . . . . . . . . . . . . . . . . . . . . . . . 37
4.6.1.1 Reducing space . . . . . . . . . . . . . . . . . . . . . . . . 37
4.6.1.2 Tuning utility calculation . . . . . . . . . . . . . . . . . . 39
4.6.2 Advanced constraint satisfaction methods . . . . . . . . . . . . . . 41
4.6.2.1 Constraint satisfiability . . . . . . . . . . . . . . . . . . . 42
4.6.2.2 Divide and conquer algorithm . . . . . . . . . . . . . . . 45
4.6.2.3 Tree decomposition . . . . . . . . . . . . . . . . . . . . . 48
Chapter 5: System Design 50
5.1 Environment concerns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.2 Complete system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.3 Realistic utility functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.4 Exploiting system design . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Chapter 6: Experimental Results and Analysis 63
6.1 CS-MRTA Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
6.1.1 Failures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.1.2 Non-random, domain-specific tasks . . . . . . . . . . . . . . . . . . 68
6.1.3 Divide and conquer algorithm . . . . . . . . . . . . . . . . . . . . . 69
6.1.4 Empirical validation . . . . . . . . . . . . . . . . . . . . . . . . . . 69
6.2 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.2.1 Complexity analysis . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.2.2 Algorithmic results . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Chapter 7: Conclusion 77
7.1 Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
References 80
iv
List Of Tables
2.1 A table defining the symbols used within this work, with examples for the
investigate task. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.1 Percentage of failures vs. Shehory and Kraus’s algorithm for random tasks
and robots. |T| = 3 and k = 2. . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2 Analysis of different approaches to the ST-MR-IA problem with respect to
communication, computation, and quality. . . . . . . . . . . . . . . . . . . 75
v
List Of Figures
3.1 A dependency graph for the example task broken into subtasks. Subtask
t
1
is the push subtask, t
2
and t
3
represent the camera subtasks, and t
4
is
the small scout subtask. The d represents the hard constraint that the
robots executing the subtasks must be different. . . . . . . . . . . . . . . . 15
4.1 Complexity of the subset enumeration problem. Each child represents a
subsetofn,oracoalitionfromsize1ton. Thesizeofeachgroupissignified
bythebinomialtotheirleft. (a)showsenumerationwithunboundedsubset
size, while (b) is bounded by size k. . . . . . . . . . . . . . . . . . . . . . 23
4.2 The allocation trees for the task in Fig. 4.4, which is divided into two
subtasks, t
1
and t
2
. (a) A brute force search tree. The two boxed leaves
are duplicate searches. (b) A tree using a constraint satisfaction search. t
1
is assigned first, then t
2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.3 Shehory and Kraus’s algorithm for coalition formation for task allocation. 27
4.4 A degenerate case of Shehory and Kraus’s algorithm. In this example
the utility is to be minimized. The utility function here is calculated by
taking coalition’s ability for the subtask capability minus a penalty of one
for coalitions larger than 1. For example, the utility of coalition (r
1
,r
2
)
for (t
1
) is 3 for the abilities plus 1 for having a size 2 coalition. In the
Preliminary Stage the possible coalitions of n are enumerated, R
1
= (r
1
),
R
2
= (r
2
), and R
3
= (r
1
,r
2
). In the Task Calculation stage the utility of
eachcoalitionwithrespecttoeachsubtaskiscalculated, onlythosegreater
thanzeroaredisplayed. TheTaskAllocationstagerunsthealgorithmwith
the coalition-to-subtask utility list, no allocation is found. There exists an
allocation, the Optimal Allocation of assigning subtask t
1
to coalition R
2
and t
2
to R
1
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
vi
4.5 ThebasicCS-MRTAsearchalgorithmforproblemsoflowcomplexity. The
TaskAllocationStageisarecursivealgorithmthatassignsasinglesubtask
at each step. The search space is the tuple of (coalition, subtask, utility)
calculated in the calculation stage. Note that the utilities in this case are
inverted for branch and bound so the algorithm is trying the minimize the
utility. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.6 Using the pigeonhole principle to guarantee fast constraint satisfaction. . 44
4.7 The decomposition of a task into two subproblems. From the point of
view of the meta-task allocator, allocations 1 and 2 of the meta-subtask
areequivalent; knowledgeofwhichcoalitionwasassignedtowhichsubtask
is unnecessary when only the all-different constraint exists. . . . . . . . . 47
5.1 Algorithm for search and rescue. . . . . . . . . . . . . . . . . . . . . . . . 53
5.2 Different representations of the example problem. (a) The original formu-
lation of the problem. (b) The classes of robots, C
n
, that are assignable to
eachsubtaskareidentified. (c)Adualrepresentationof(b),wherethetrue
dependencies between subtasks are identified using information from gath-
ered from (b). (d) Artificial restrictions are made on the classes that can
be assigned to each subtask. (e) A dual representation of the task depen-
dency graph, where the actual subtask dependencies are now represented
by the subtask’s assignable robot classes. (f) The tree decomposition of (e). 61
6.1 Testusingrandomtaskstoseetheeffectsofdifferentconstraintsatisfaction
techniquesonexecutiontime. bbreferstobranchandbound,fctoforward
checking,andmrvtotheminimumremainingvalueCSPheuristic. |T| = 3
and k = 2 in this test. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
6.2 Test using random tasks to see the effects on varying n on the optimal
search algorithm, with |T| = 3 and k = 2. . . . . . . . . . . . . . . . . . . 65
6.3 Execution time of different stages of the allocation algorithm. |T| = 3 and
k = 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.4 Execution time varying |T| and k on the complete CS-MRTA algorithm.
n = 20. When |T| was varied, k = 2. When k varied |T| = 3. . . . . . . . 67
6.5 Varying |T| over different n’s to see the performance of the Divide and
Conquer algorithm over the CS-MRTA algorithm. (a) n = 16, k = 2. (b)
n = 17, k = 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
vii
6.6 Simulation of the algorithm in Player/Stage. Example of a Move task. In
(a) the coalition has reached a victim and by (b) have moved the victim
to a safe zone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
6.7 (a) The complete algorithm for solving the ST-MR-IA MRTA problem. w
is the maximum tree width of the decomposed problem. |T|
max
and n
max
are the max sizes solvable by the system within the time limits. (b) . . . 74
viii
Abstract
Coalition formation has become a relatively important subset of multi-robot task alloca-
tion of heterogeneous teams. The problem involves allocating subsets of a team, called a
coalition, tothesubtaskswithintasks. Inthiswork, taskscomefromcomplexdomainsin
which there exist many interdependencies between the subtasks. Many aspects of coali-
tion formation in this setting will be studied with the goal of deciphering the algorithmic
and system design necessary to achieve both good performance and accurate results.
Coalition formation for heterogeneous multi-robot systems is primarily an algorith-
mic problem that has already been approached in multiagent systems and robotics. The
research thus far has not fully addressed complete and optimal allocation of highly in-
terdependent multi-robot tasks, the major goal of this work. However many ideas from
previous work can be borrowed and extended. Constraint satisfaction provides a well-
studied framework for this investigation and therefore the selection and application of
their techniques to multi-robot allocation are studied to produce an optimal polynomial
time algorithm. Following this is the identification and analysis of other methods such as
constraint optimization methods like branch and bound, as well as satisfaction methods
including constraint propagation, and a novel algorithm that uses divide and conquer to
reduce the runtime complexity.
ix
The other side of this work regards the modeling of the problem and the design of
the system. The definition of the problem’s assumptions and goals can be used to find
reasonable heuristics that reduce the space prior to and during the search. Design of the
utility function can also hamper or benefit the performance of the allocation algorithm.
Specificmodelingdecisionssuchastherecognitionofclasseswithintheteamofrobotscan
be combined with the constraint satisfaction algorithm to allow for tree decomposition
to further reduce the problem complexity.
In the end this work provides a survey of the constraint satisfaction techniques avail-
able for solving complex problems such as search and rescue, viewed from the ground
up. The viewpoint aids in highlighting the delicate relationship between problem as-
sumptions, modeling, algorithmic design, and system design, which can all be exploited
specifically to help find higher quality solutions more efficiently for constraint satisfaction
problems in complex domains.
x
Chapter 1
Introduction
Robotics technology is quickly growing out of military and scientific research and into
novel environments such as households and classrooms. Significant progress has been
made on many new types of problems, with recent work on complex tasks – such as those
involving teams of robots – gaining a great deal of attention. One particularly appealing
trend is the use of robots to address tasks that are inconvenient or difficult for humans.
However many of these types of problems bring a degree of complexity which challenge
many of today’s algorithms.
Established ideas can be leveraged to help tackle these problems. Multi-robot co-
ordination already draws contributions from both hard and soft sciences. The field is
rich with focused bodies of research. This work aims to achieve a goal of similar scope:
To discuss multi-robot coordination of heterogeneous teams executing complex tasks in
realistically modeled domains with the specific goal of making high quality allocations
efficiently.
The allocation of resources is one of the most fundamental and difficult problems in
computer science. Numerous techniques exist for many problems, but as the complexity
1
of their domains increase, the problem of allocation can become significantly harder to
the extent that many are in the NP class. The motivation for this work is the realization
that many important multi-robot problems exhibit high degrees of complexity and there-
fore more research must be conducted to study the issues accompanying the design and
allocation of robot teams. This work will draw from a set of techniques from artificial
intelligence and robotics, including distributed problem solving, constraint satisfaction,
and multi-agent systems. Existing work from these fields will be discussed and applied to
the defined problem, and new techniques such as divide and conquer will be introduced.
These and others will be analyzed to help address the question of how to efficiently form
high-quality coalitions for complex domains.
1.1 Complex problem domains
Multi-robot coordination is an exciting new problem and many of the situations being
considered for robotic execution are challenging many of today’s algorithms. Search and
rescue is one of the many rich domains that bring this challenge, carrying many qualities
found in interesting problems such as dynamic, unknown, and even hostile environments.
The initial effort in robot-aided search and rescue went into designing specialized
hardware to handle tasks in which society could immediately receive some benefit. Dif-
ferent hardware sensors such as infrared or heat-sensitive cameras could be quickly tested
and deployed. Human-robot interaction and intelligent user interfaces have also been
studied to help bolster the cooperation between man and machine [1]. To spur overall
research, competitive vehicles such as the RoboCup-Rescue league have been introduced
2
[7]. With this much attention, many researchers from other fields have come and brought
their knowledge and experience. The multi-agent systems (MAS) community has made
significant contributions to both search and rescue and multi-robot coordination as a
whole, with important achievements such as the Contract Net Protocol [13].
More responsibility is being pushed onto machines, requiring that more effort be
put into their design. The introduction of complex environments has brought a number
of new concerns such as the allocation of interdependent tasks and the importance of
system robustness to high rates of hardware and communication failure. As the difficulty
and demands have increased, the issues of allocation through coalition formation – the
problem of assigning subsets of the robot team to subtasks with a task – has emerged as
an important problem.
1.2 Objective
The first part of this work will identify properties of the multi-robot task allocation
(MRTA) problem that have not been thoroughly investigated in coalition formation re-
search, andfromthereitwilldistillthespecificMRTAproblemtobeaddressed. Thiswill
then be refined further by defining the problem assumptions and model. These choices
provide a reference for determining the advantages and disadvantages of decisions made
in the remainder of the work.
The next objective is to review current coalition formation (CF) research, identifying
differences and issues when applied specifically to hard problems such as search and
rescue. Constraint satisfaction will be introduced as a solution to the CF problem. This
3
method will provide a well-understood framework for approaching multi-robot allocation
of complicated tasks. The specific modifications and extensions that are necessary for
the constraint-based system will be discussed and through simulated experiments the
approaches will be analyzed.
System design issues will also be explored. Building effective multi-robot systems
requires thought on more pragmatic issues such as the number and types of robots to
deploy, the actual utility functions used, and hardware and communication failure con-
tingency plans. The attention to these types of concrete issues is necessary to achieve
good performance and quality results in this domain.
Both the system and algorithmic design have, in both directions, a highly causal
relationship. Certain choices, such as the homogeneous or heterogeneous composition of
a team, will significantly affect the design and performance of the allocation algorithm.
Simplifying the problem would be a simple way to reduce the complexity of the system,
but for many domains that decision would restrict or oppose the goal of finding the best
solution. For instance deploying a homogeneous team of small robots – as opposed to a
heterogeneous team of small, medium, and large robots – to a disaster site would severely
limit the range of physical tasks that could be executed. Therefore the final objective
is to study how the two objectives influence each other, investigating how to mitigate
negative reactions and exploit those that may improve performance.
4
Chapter 2
Problem
Autonomous execution of tasks is an extremely difficult goal. The first robotics efforts
revealed that tasks which seemed algorithmically simple were very hard to accomplish
in the physical world. This is in part due to the extra considerations present during
real execution of a task compared to a controlled simulation. Adding to this difficultly,
harder tasks such as those in search and rescue require that multiple robots coordinate
their effort. Some examples:
• An operator may want to view a particular area from multiple vantage points to
make a more accurate assessment of a disaster situation. A coalition of robots can
be formed, consisting of a helicopter for aerial surveillance and multiple land robots
providing ground-based views.
• Multiple robots may be required to perform difficult physical tasks such as clearing
heavy debris behind which a victim may be trapped. Two or more robots may be
needed to move the obstruction.
5
• Robots sometimes need assistance for what is normally a single-robot task. For
example, a team member can be used to help navigate another through a difficult
passageway.
Also some single-robot tasks can be better executed if handled by multiple robots. A
moving task requiring only one robot could possibly be better executed by two or more
robots. Similarly if no one robot is available, a task requiring a push output of 20 could
be executed by two robots with individual abilities of 10.
The difficulty of these tasks provides some of the basis for why this research is impor-
tant. As more complicated tasks are given to robots, closer analysis must be done.
2.1 Example problem
A natural disaster has just occurred. After a situational assessment, a team of robots
along with a human operator has been dispatched to aid in the task of searching for
and rescuing the victims. The team is composed of twenty robots each with differing
capabilities:
• Five robots are autonomous helicopters and thus have the ability to fly. They are
also equipped with high-resolution color cameras.
• Five robots are large ground-based vehicles fitted with laser range finders, a black-
and-whitecamera,andgripperscoupledwithapowerfulenginetoallowthemachine
to move large obstacles.
6
• Fiverobotsaremedium-sizedgroundmachinesthathavetheequipmentandknowl-
edge to perform simple medical diagnostics. They also have cameras and can move
objects, though at a smaller scale than the large robots.
• The remaining five robots are small, dexterous scout-like robots that can navigate
more difficult terrain. They are equipped with a simple camera and microphone.
Note that there are many robot capabilities and the different robots may overlap in
them. For example many robots have cameras though the exact performance character-
istics of each differ. Some robots also have unique abilities such as the aptitude to fly.
Due to the nature of physical hardware, there is even variation among similar robots;
two flying robots may have different abilities to execute a given task due to individual
characteristics such as their amount of remaining power, thereby affecting their utility
and subsequently decisions regarding task allocation.
The system is deployed along with certain knowledge about the disaster. The envi-
ronment is a bounded area to be searched in which five victims are scattered in unknown
locations. In the beginning the team is to split off and commence the search task. When
arobotortheoperatordiscoverswithhighprobabilitythatanareamaycontainavictim,
a task defined by the operator is introduced which requires a coalition of robots, i.e. a
subset of the team, to execute.
Given the supplied information about the setting, certain tasks will likely occur.
Robots may stumble upon clues such as movement or cries for help that hint that a
site has high victim probability. After this is discovered a task is introduced calling for
a coalition of robots to investigate. This task is defined in such a way as to allow the
7
team to autonomously determine the appropriate allocation of resources. An example
task called investigate follows:
A possible victim is located in an area with large debris. The goal of the task
is to investigate an area by removing the debris to allow for a closer search for
the victims. One subtask is defined requiring a coalition with pushing power
greater than 20 to clear a path. Another two subtasks are required; each
coalition needs a camera to oversee and manage the pushing task, therefore
theyoperateundertheconditionthatthecoalitionsdonotshareanymembers
with the one assigned to the pushing subtask. While the pathway is being
cleared, a small robot with video capabilities is required to ensure that the
debris-removing coalition has not already encountered a victim; this coalition
also cannot share members with any other subtasks’ coalition.
Only knowledge about the resource requirements and their constraints are necessary
for the task allocation portion of this problem. Due to the heterogeneous composition of
the team, tasks are flexibly defined by their resource requirements so that any coalition
with the correct resource signature can be assigned. For example, a primitive operation
such as pushing could potentially be executed by any coalition of one or more robots; it
is up to the team to decide whether it is desirable for the pushing subtask to be allocated
to a particular coalition. This allows for a larger search space and thus more opportunity
in case some members of the team are busy or otherwise unavailable.
8
2.2 Problem statement
Formally the multi-robot task allocation problem being addressed in this research is
similar to many well-understood problems including the set partitioning problem (SPP)
[12] and the general assignment problem (GAP) [11]. The goal is to find, given a single
task T, the best assignment of a greater coalition of robots to that task. Table 2.1 is a
referenceforthesymbolstobeusedinthisworkwithexamplesfromthesampleproblem.
There is a heterogeneous team of robots, R, composed of individual robots, r
i
, such
that R = [r
1
,r
2
,...r
n
]. Each individual has a range of abilities, r
i
= [c
r
i
1
,c
r
i
2
,...c
r
i
c
], across
a fixed number of possible capabilities, C
i
= [c
1
,c
2
,...c
c
]. Each robot also has an ability
valueforeachcapability, e.g. c
r
i
1
...c
r
i
c
, whichisrepresentedbyanon-negativerealnumber
with zero representing the lack of ability to fulfill that particular capability. A task is
composed of subtasks, T = [t
1
,t
2
,...t
t
], where each subtask has a number of capability
requirements, t
j
= [c
t
j
1
,c
t
j
2
,...c
t
j
c
]. Coalitions are made up of a group of robots of size
one to n, called R
i
, and each has a capability list specified as R
i
= [c
R
i
1
...c
R
i
c
] which
is calculated from the members of the coalition. A coalitions is to be assigned to each
subtask within the task, and the group of coalitions assigned to the entire task is called
a greater coalition.
The problem involves finding the best assignment of coalitions to every subtask under
the conditions that:
1. The capability for each coalition is greater than or equal to the requirements for
each subtask, i.e. c
R
i
k
≥ c
t
j
k
for all k from 1 to c.
9
2. The coalitions for each subtask do not violate any constraints set by each subtask,
e.g. two subtasks may require that their assigned coalitions have different members
and therefore the condition states that the coalitions must have different members.
Each coalition has a utility with regards to a subtask which is specified as U
R
i
t
j
. In
addition to the conditions above, the algorithm must also try find the set of coalition-to-
subtask assignments such that utility of the greater coalition is maximized, represented
as U
R
i
,R
j
,...
T
.
2.3 Related Work
With no restrictions, performing a standard search to allocate coalitions to subtasks is
NP-hard because the enumeration of all coalitions of a team requires exponential time
[12]. Adding to the difficulty, the enumeration and utility calculation must occur at
each task introduction since the available robots and their utilities change over time.
One method is to design a heuristic such that the entire space of coalitions need not be
searched, which is practical in cases where there are many robots or the complexity of
the tasks are high. On the other hand the heuristic solution will often be suboptimal and
sometimes may not find a solution even when one is present.
Current approaches to multi-robot task allocation make this trade-off for efficient
solutions. Shehory and Kraus have a general solution to coalition formation for the
multiagent domain for tasks without interdependencies [12]. Vig and Adams took this a
step further to find efficient solutions for multi-robot tasks with dependencies, however
the algorithms were not complete and solution quality was not sufficiently discussed [14].
10
Other work in multi-robot task allocation targets other issues such as distributedness of
private information [11].
Little work has targeted this specific set of goals: analysis of multi-robot task alloca-
tion of heterogeneous teams to highly constrained tasks, addressed alongside the issues of
problem modeling and system design for complex domains.
11
Symbol Explanation Example
T A single task The investigate example task.
t
j
A subtask within a task The pushing capability.
R The team of robots The entire team of twenty search and rescue robots.
R
i
A coalition A group of two pushers for a push subtask.
r
i
A single robot One autonomous helicopter in the team.
n The total number of robots The size of the team, 20.
C The list of capabilities The entire set of capabilities, e.g. push, video-record, fly, etc.
c The number of capabilities The size of C.
c
r
i
1
r
i
’s ability to do c
1
Robot i’s ability to push objects.
c
t
j
1
t
j
’s requirements for c
1
Subtask j’s minimum ability requirement for the pushing capability.
U
R
i
t
j
R
i
’s utility to be allocated t
j
A particular coalitions utility to be assigned to a pushing subtask.
U
R
i
,R
j
,...
T
Utility of the greater coalitions to T The utility of the four coalitions with respect to the investigate task.
k The maximum coalition size The largest coalition needed to accomplish any particular subtask.
p Pruning bound Maximum number of coalitions pruned by one subtask assignment.
w Tree width The tree width of a subproblem.
Table 2.1: A table defining the symbols used within this work, with examples for the investigate task.
12
Chapter 3
Complex Domains
The objective of this work is to develop an algorithm that increases the performance
and solution quality of multi-robot task allocation in complex domains. However the
definition of complex domains is at this point loose. How they are actually modeled has
major implications on the performance and accuracy of the solutions.
The ideal problem model will capture all relevant information, such as realistic task
models and subtask constraints, to help increase the accuracy of the solutions. However
an overabundance of information can burden other parts of the MRTA algorithm, and
therefore an implicit goal of this work is to identify the trade-offs between modeling the
domain for good solutions and good performance.
This work defines complex domains as those in which difficult dependencies such as
the all-different constraint exist, and domains in which rich utility functions can be used
with good results. The extent to which the constraint and utility models are defined
along with their limitations are also discussed.
13
3.1 Intertask dependencies
Dependencies commonly occur between realistic subtasks, and they can be categorized
into satisfaction dependencies and utility dependencies. These are respectively analogous
to hard and soft constraints: Satisfaction dependencies are hard constraints that if vi-
olated will invalidate a proposed allocation. In the example problem the subtask that
requires that the members of the camera coalition be different from the pushing coalition
is a different hard constraint. In this work dependencies and constraints will be used
interchangeably.
Utility dependencies are soft constraints that modify the utility of an allocation based
on the conditions of the dependency. The utility for a greater coalition to a subtask may
be higher of lower if certain conditions are present. For example two robots may work
particularly well together for a certain task. Fig. 3.1 shows the subtask dependencies of
the example task.
3.1.1 Common dependencies
Of the example search and rescue tasks described, the most common interdependency
is the different constraint. A pair of subtasks may need to be executed by different
coalitions,representedasasingled-edgeinthetaskdependencygraph. Anothertaskmay
require that all subtasks be executed by different coalitions, the all-different constraint,
represented as a complete graph of d-edges.
Analternate definitionof the all-different constraintis thatmembers ofeach assigned
coalition must be disjoint. For example, using the multi-robot moving task performed
14
Figure 3.1: A dependency graph for the example task broken into subtasks. Subtask t
1
is the push subtask, t
2
and t
3
represent the camera subtasks, and t
4
is the small scout
subtask. The d represents the hard constraint that the robots executing the subtasks
must be different.
15
in [4], one or more robots are needed to push a box while a separate robot was required
to oversee where the others were pushing. In this task trying to assign one coalition
to perform all of the subtasks would violate the all-different constraint and invalidate
that proposed allocation. The all-different constraint will be assumed for all of the tasks
described in the remainder of the work unless explicitly stated.
Other satisfaction dependencies such as the same-class constraint exist. Again using
the push task, many different groups of robots could potentially perform it. However if
themulti-robotcoordinationalgorithmisimplementedinaparticularway, itmayrequire
that all of the pushers are of the same type.
3.1.2 Implications
The recognition of task dependencies introduces a whole new set of problems to be solved
by multi-robot teams. By using resource requirements and constraints to define tasks
in a general way – as opposed to defining subtasks by the explicit groups of robots that
can execute it – a larger space of solutions can be searched. Allowing coalitions instead
of single robots to be allocated to a subtask also increases the size of the search space
favorably; now a coalition of robots could execute a task if previously no single capable
robot was available. This is especially important in domains where resources are scarce
or misallocation often occurs, and missed allocations are detrimental. Such is the case in
critical situations like search and rescue.
The all-different constraint will be the main one addressed in this work, and thus the
limitednumberoftypesdoesreducetherangeoftasksthatwillbeexecuted. Othershave
been studied that include temporal or precedence constraints [12], in which execution of
16
a subtask must occur before or after another. This research will explicitly address only
a few dependencies of the satisfaction and utility types, however it may be possible to
extend many of the ideas presented to others.
3.2 Rich utility functions
Thechoiceofhowindividualandgrouputilitiesaredefinedisanimportantdesignconsid-
eration for complex domains, one that has major implications on the choice of algorithm.
For example in the search and rescue task, the utility function would likely be propor-
tional to the distance of the coalition to the task site. Since the robots are constantly
moving, this value is continually changing and therefore these values must be locally
calculated at each iteration. This highly complicates the problem if perfect utilities are
desired. This work will make the assumption that any changes in utilities that occur
during the task allocation stage are negligible. Other important factors that influence
the utility function will be described; they are each assumed to be modeled explicitly in
the task constraint graph or implicitly within the utility function.
3.2.1 Implicit constraints
Increasing the complexity of the system could affect the performance and applicability of
the allocation algorithm. For instance if each subtask execution was bound to a shared
and limited resource, this would require the recalculation of utilities at each subtask
assignment since the resource may have been consumed. This is one example of an
implicit constraint between coalitions and resources which cannot be easily represented
by the current task-centric constraint graph. To model them, they are instead captured
17
within the utility functions. As the combined task utility is being calculated, invalid
allocations due to conflicts are recognized and reflected.
Similarlycoalition-to-subtaskutilityfunctionswhichdependonthestateoftheentire
set of robots, n, would require recalculation of utilities after each subtask allocation,
because after each calculation this state has changed [12]. There are methods to handle
thiscase,andthatusedinthisimplementationistoagainmovethislogictowhensubtask
utilities are calculated and combined.
3.2.2 Implications
Findinghighqualitysolutionsrequiresanaccurateinterpretationoftheproblem,however
there is a point at which realistic models over-complicate other aspects of the system.
Adding soft constraints will have implications on the algorithm’s calculation of utility.
For instance, imagine a task requiring two coalitions of arbitrary strength to push an
object forward. The execution model may be defined such that the coalitions must push
with equal strength from both sides. If two coalitions of equal pushing ability opt for
the task, then the pushing utility of their greater coalition is the sum ability of both.
However if the coalitions had different individual pushing utilities, then the total utility
would be smaller, i.e. twice the ability of the weaker one, because the stronger one must
reduce its own output to compensate for the weaker. These conditions must be handled
by the algorithm. In some cases soft constraints can be avoided by introducing hard
constraints, such as in this case the same-class constraint. Some utility dependencies can
be replaced by hard constraints in this way, however imposing unneeded constraints in
this way would limit the space of possible solutions.
18
Explicit constraints are modeled in the constraint graph, and any additional relevant
information is modeled in the utility function. However there is other pertinent infor-
mation that cannot be easily included; those that cannot be represented in either the
constraint graph or utility function are our outside the scope of this work. Also extrane-
ous details, such as fine-grained changes in utilities that occur during the algorithms, will
be assumed to be minimal and ignored. The algorithms will be shown to still produce
good results given these conditions.
19
Chapter 4
Multi-Robot Task Allocation
Many multi-robot problems including search and rescue can be divided into three stages:
task decomposition, task allocation, and task execution. Task decomposition involves the
steps necessary to break a task into smaller elements, i.e. subtasks, which are solvable by
a small group of robots called a coalition. The task allocation problem describes all the
actions necessary for deciding which robots in the team will execute each of the subtasks.
The final step is task execution in which the task is performed. Afterwards the coalition
disbands. The process is repeated when a new task is introduced. Because the depth of
research for each stage is quite large, this work will focus mainly on task decomposition
and allocation.
4.1 Task decomposition
Complex tasks can be divided into smaller subtasks, each requiring certain capabilities.
Some subtasks require only the presence of a capability, e.g. flying, represented by a non-
zero value, while others require a certain ability with regards to a particular capability,
20
e.g. the ability to push at least 10 units of power, which is represented across a range of
positive values.
Tasks can be measured by degrees of complexity. A moderately complex task could
be defined as one with one to five subtasks, where each may require a number of robots
to execute it. Previous MRTA research has focused on simpler tasks which can be broken
into smaller subproblems and solved independently [12]. This greatly simplifies the al-
location problem, however solving the pieces independently in this setting is suboptimal
due to the dependencies commonly found between subtasks. Trying to allocate subtasks
independently could potentially generate a solution, but there are no guarantees to the
solution quality and algorithmic completeness. Nonetheless decomposing tasks is a useful
heuristic for more complex problems that will be addressed in later chapters.
Alltaskswillhavebeendecomposedtothemostbasiclevelsuchthatnodependencies
exist within a subtask. Each subtask is itself a coalition formation problem, although a
trivial one since no constraints exist within it. The actual problem of decomposition
is not addressed by this work, as developing a good algorithm is itself a sufficiently
challenging problem. In the disaster scenario one possible solution is that upon locating
a task, a human operator will be notified and asked to analyze the situation and define
the decomposition. To simplify this work, the set of tasks have already been defined.
4.2 Task Allocation
Gerkey’s work [5] provides a detailed explanation and taxonomy of the MRTA problem.
Given that many of the search and rescue tasks involve multiple robots, the focus will
21
be the multi-robot (MR) class of problems. Also it will be assumed that all robots are
only capable of executing one task at a time (ST). The search and rescue task naturally
describes situations where little is known about the environment; some modeling or pre-
diction of the types of incoming tasks may be done however the benefit of doing so is very
problemspecificandthusoutsideofthescopeofthisresearch. Thereforethefocuswillbe
on assigning each task as it is introduced, placing it in the instantaneous assignment (IA)
classofproblems. ThecompleteMRTAformalismisST-MR-IA.Itwillbeassumedthat
robots that are executing a task will not be considered for new task allocations until they
are finished, because allowing this would add unnecessary complexity such as modeling
of the utility of removing a robot from a particular task to be assigned to another.
4.3 Search
The MRTA problem for the search and rescue domain is being approached as a search
problem. The search space is initially of exponential complexity due to that of subset
enumeration; finding a complete allocation algorithm for a task requires a search through
this exponential space.
For each subtask assignment the number of possible coalitions is exponential, on the
order of:
n
X
i=1

n
i

The binomials,

n
i

, signify the size of the enumeration of coalitions from the team
n of a particular size i. At each level the size complexity of this enumeration is O(2
n
).
22
Figure 4.1: Complexity of the subset enumeration problem. Each child represents a
subset of n, or a coalition from size 1 to n. The size of each group is signified by the
binomial to their left. (a) shows enumeration with unbounded subset size, while (b) is
bounded by size k.
23
Different heuristics can be used to reduce the space, such as reducing the number of
subtask coalitions at each level to a tractable size, as seen in Fig. 4.1b. A reduction can
be achieved by bounding the size of coalitions by k, reducing the number of children at
each level to a polynomial complexity of O(n
k
). However the entire task search space is
still exponential to the number of subtasks in the task.
The integer bound, k, represents the maximum sized coalition needed for a subtask
which should be derived or estimated based on knowledge about the types of tasks that
will be introduced. The rationale for bounding this space is because many subtasks
require only a limited number of robots less than n, and also because the domain is not
super-additive. Super-additivitywithregardstoMRTAproblemsdescribesthoseinwhich
larger coalitions always have higher utilities than smaller ones. In search and rescue this
is often not applicable because resources are limited, and robots in this setting have a
default task to execute: searching other locations for probable victims. Therefore if a
larger coalition has no benefit over a smaller one, then the extra tied-up resources would
be better spent searching. Additionally, having a large coalition of robots assigned to
a subtask could introduce unforeseen problems such as interference with execution and
thus the degrading of performance.
Many methods have been developed for solving search problems, each with different
trade-offs in terms of solution quality and completeness. A brute force complete search is
the most straightforward way to find allocations in an optimal manner; it is shown for a
simple problem in Fig. 4.2a. The entire tree is searched and the best solution is returned
if found. Using this method to search for an allocatable coalition would be on the order
of
24
Figure4.2: TheallocationtreesforthetaskinFig. 4.4,whichisdividedintotwosubtasks,
t
1
and t
2
. (a) A brute force search tree. The two boxed leaves are duplicate searches. (b)
A tree using a constraint satisfaction search. t
1
is assigned first, then t
2
.
25
|T|−1
Y
i=0
(|T|−i)(n)
k
This is of complexity O(|T|!n
|T|k
) [10]. This is derived from Fig. 4.2a, where at each
level each coalition in the list of enumerated coalitions, n
k
, is assigned to each remaining
subtask, |T|. The result is that each coalition-subtask combination is checked multiple
times when traversing the tree of possible allocations.
4.4 Existing coalition formation algorithms
A great deal of research has been attributed to the problem of complex task allocation.
Many algorithms are applicable to the general problem of heterogeneous MRTA, however
notalladdressthepresenceoftaskandresourceconstraints. Thosethatdohavegenerally
focused on reducing the complexity of task allocation through heuristics, meaning the
algorithms are possibly suboptimal and incomplete.
4.4.1 Shehory and Kraus’s algorithm
Shehory and Kraus presented a distributed, greedy algorithm for task allocation among
heterogeneous agents [12]. Their algorithm, modified slightly to match this domain, is
shown in Fig. 4.3. The preliminary stage first subdivides the problem among the agents.
When a task is introduced, the calculation of utilities for each coalition occurs in parallel.
From this the agents distributedly determine the best allocation.
26
Preliminary Stage:
1. Calculate all of the possible coalitions from the space. Divide the coalitions
into groups and assign on to each robot.
2. Each robot will contact the robots in their group to receive their capa-
bilities. The robot is now committed to calculating the utility for those
coalitions.
Task Calculation Stage:
1. Upon locating a task, message each robot the task details.
2. Each robot will calculate the utility value for each coalition in its list with
respect to each subtask. This value is the sum of the market values for
executing the subtask minus any costs specific to the coalition. These
values are stored in a list.
Task Allocation Stage:
1. Each robot with announce their coalition with the best utility.
2. The coalition with the best overall utility will be chosen to execute its
respective subtask.
3. Each robot prunes from its list of utilities those that contain the task
or share a coalition member of the recently assigned task and coalition.
Afterwards the utilities are recalculated (2. from the Task Calculation
Stage).
4. This process is repeated until there are no more subtasks, or no coalitions
are left and thus suitable assignment cannot be found.
Figure 4.3: Shehory and Kraus’s algorithm for coalition formation for task allocation.
27
The complexity of the preliminary and calculation stages are O(n
k
)
1
for each agent
given that it divides the space between the n robots and bounds the coalition size by
k. The actual allocation stage – or the search algorithm – is greedy and efficient, going
throughonly|T|iterations,orthenumberofsubtasks. Overallthealgorithmiccomplexity
isO(|T|n
k
)whichisveryefficientandlineartothenumberofpossiblecoalitions. Shehory
and Kraus also formally and empirically showed that the allocations produced by this
greedy algorithm are in many cases very close to optimal.
There are minor issues in this domain that do not make Shehory and Kraus’s algo-
rithm directly applicable. First is the problem of dependencies that often occur between
subtasks for search and rescue tasks. This was mentioned and identified as an issue out-
side the scope of the particular work. However they proposed one solution: To combine
dependent subtasks into a unified task and then use the algorithm. However this com-
bined task again is an instance of a new, though smaller, coalition formation problem.
Also these unified tasks are still restricted in coalition size by k and thus solution quality
and completeness are affected, e.g. two subtasks that could have originally been executed
by two k-size coalitions can no longer be allocated to those two coalitions if the subtasks
are combined into one.
4.4.2 Vig and Adams algorithm
Vig and Adams extended Shehory and Kraus’s algorithm to provide some of the com-
munity’s first empirical results for ST-MR-IA problems [14]. They made a number of
1
The actual complexity for each agent is actually O(n
k−1
) because Shehory and Kraus divide the
space of enumerated coalitions evenly among the individual agents who in parallel calculate the utilities
for their respective group of coalitions.
28
contributions: To reduce the search space, they exploited information about task con-
straints so that more coalitions could be pruned at each subtask iteration. This occurs
in Step 3 of the Task Allocation stage in Fig. 4.3 alongside the pruning stage of Shehory
and Kraus’s algorithm. Their results showed it to have positive effects on execution time,
i.e. the use of constraint propagation to remove constraint-violating coalitions from the
next iteration’s remaining O(n
k
) search space was of negligible effect on search time. It
was still dominated by other stages of the algorithm.
Additionally, Vig and Adams addressed the calculation of utilities specifically for
robotics problems. By using a metric to calculate coalitional balance, coalitions that
were more fault tolerant or more economical in resources could be preferentially chosen.
Finallytheyprovidedanalysisofthealgorithm’scommunicationload,animportantfactor
in building scalable multi-robot systems [5].
4.4.3 Issues with applying previous work
Shehory and Kraus said very little about how the coalition utility values should be cal-
culated. In their algorithm utility was calculated by subtracting the market cost, the
negative utility of assigning a coalition, from its market value, the positive utility. The
definition of the costs and values can encompass any kind of domain-specific information
about the problem, therefore they left details how they should be used to the specific
implementations.
Vig and Adams realized this and provided insight into determining utility for the
heterogeneous multi-robot domain through their idea of coalition balance. The definition
of these costs and values is not trivial; in theory providing a perfect calculation of utility
29
– finding a function that contains all information about a problem and thus in this case
accounts for all the satisfaction and utility dependencies between subtasks and coalitions
– could provide an optimal to the allocation problem at a reduced time complexity. How-
ever to calculate these perfect values, which requires accurately combining all pertinent
information about the problem, would require solving the coalition formation problem
itself.
Unfortunately poorly composed utility functions can provide bad answers, especially
if the algorithm does not perform a complete search. Fig. 4.4 illustrates this problem.
Using a simple utility calculation that follows the values and costs described by Shehory
and Kraus, there are degenerate cases where the algorithm will fail and an allocation
will not be found although one is present in the search space. The algorithm does not
backtrack and therefore the order of subtask selection is extremely important. This
situation could be avoided for this example by using different utility function, such as one
that prioritizes subtasks that have very few potential coalitions, such that t
2
is allocated
in the first iteration. Though there is a solution in this case, it is hard to generalize the
design of utility functions to guarantee completeness.
4.5 Constraintsatisfactionapproachformoderatelycomplex
problems
Givenalistofpossiblecoalitionassignmentsforeachsubtaskandtheimplicitall-different
constraint between subtasks, determining which assignment will produce the best greater
30
Figure 4.4: A degenerate case of Shehory and Kraus’s algorithm. In this example the
utility is to be minimized. The utility function here is calculated by taking coalition’s
ability for the subtask capability minus a penalty of one for coalitions larger than 1. For
example, the utility of coalition (r
1
,r
2
) for (t
1
) is 3 for the abilities plus 1 for having a
size 2 coalition. In the Preliminary Stage the possible coalitions of n are enumerated,
R
1
= (r
1
), R
2
= (r
2
), and R
3
= (r
1
,r
2
). In the Task Calculation stage the utility of
each coalition with respect to each subtask is calculated, only those greater than zero are
displayed. The Task Allocation stage runs the algorithm with the coalition-to-subtask
utility list, no allocation is found. There exists an allocation, the Optimal Allocation of
assigning subtask t
1
to coalition R
2
and t
2
to R
1
.
31
coalition is a set partition problem, i.e. finding which partition of the space of n robots
into |T| coalitions will have the highest utility
2
.
Another method of formulating this problem is as a constraint satisfaction problem
(CSP). Both modeling the problem as a CSP or SPP will reduce the number of duplicate
search paths from the brute force complexity of O(|T|!n
|T|k
) to a complexity of O(n
|T|k
)
[10]. This occurs in CSP with the realization that the order of each subtask assignment
doesn’t matter, therefore only one subtask needs to be assigned at each level, as in Fig.
4.2b. However even this approach is intractable if T or k are left unconstrained. In this
work both values are assumed to be a fixed size, however the problem is still difficult for
tasks where |T| or k is large.
Applying constraint satisfaction techniques can significantly reduce the search time,
thoughitdoesnotreducethespacecomplexity. Forwardcheckingimprovessearchtimeby
pruningthesearchspaceofinvalidcoalitions. AlreadyShehoryandKraus’salgorithmuse
a method similar to forward checking by removing conflicting coalitions as each subtask
is assigned. Vig and Adams explicitly modeled tasks constraints and thus were able to
use arc consistency, a form of constraint propagation, to remove additional impossible
coalitions. These and other techniques will be incorporated into a new algorithm.
Thefollowingsectionswilldiscussthegenerationofacomplete,optimalsolutioninan
O(n
|T|k
) algorithm through the use of constraint satisfaction and constraint optimization
techniques. Constraint satisfaction is used directly to help reduce the amount of the
tree searched. Constraint optimization is used to improve the algorithm’s runtime by
finding good solutions faster. A common approach, branch and bound, decreases the
2
The set is actually split into |T|+1 partitions, one for each of the subtasks in T and one extra for
the remainder of the team.
32
search space by storing the current best solution and thus not branching on those that
cannotbebetter. Stillothermodificationscanbemadetoimprovethealgorithm’sactual
performance. For example it can easily be modified into an any-time algorithm by timing
out and returning the best solution after a given period.
4.5.1 Constraint Satisfaction MRTA Algorithm
The basic constraint satisfaction MRTA (CS-MRTA) algorithm concentrates on deter-
mining the optimal solution to the problem for tasks of moderate complexity. Moderate
tasks will be defined by the runtime of the CS-MRTA algorithm for the task, and there-
fore complexity can refer different values of n, |T|, and k such that CS-MRTA can be
completedwithinadesiredtimebound. TheeasiertoimplementtechniquesofCS-MRTA
are sufficient to solve these problems.
The algorithm, CS-MRTA, presented in Fig. 4.5 partially builds of Shehory and
Kraus’s algorithm but reduces the number of stages to two. In the first stage, the list of
availablerobotsaregather. Fromthis,validcoalitionsareenumeratedandtheutilitiesare
calculated with respect to each subtask, producing a list of coalition-to-subtask utilities.
These are represented as a tuple (R
i
,t
j
,v) which are the coalition, subtask, and utility
respectively, which is equivalent to U
R
i
t
j
. This list is used as the search space for the
allocation stage.
The most computation occurs within search algorithm of the allocation stage. This
is a modified version of the general constraint satisfaction algorithm [10]. A combination
of techniques is used: The Minimum Remaining Value heuristic (MRV) is used to reduce
the search space along a branch by assigning the most constrained variable first. This is
33
calculatedbyfindingthetaskthathastheminimumnumberofcoalitionsbeingconsidered
for it left. Doing so will increase the probability that poor solution paths are not taken
because constrained subtasks, which fail sooner, are checked first [10].
Branch and bound is a constraint optimization technique and thus used primarily to
help find optimal answers. One of the conditions for branch and bound are that each
subtask utility value is admissible with respect to the combined utility values, similar
to the conditions of A*. This assumption allows running assignments to be checked
meaningfully against a complete assignment, so that search paths for which the next
assignment is already worse than the current solution will not be followed. Constraint
propagationtechniquessuchasforwardcheckingaremovedwithinthisbranchandbound
check, allowing the next iteration’s space to be pruned only when necessary.
This algorithm is a simple reformation of Shehory and Kraus’s and Vig and Adam’s
algorithm into a constraint satisfaction formalism, making it optimal and thus complete
at the expense of additional runtime. The task calculation stage enumerates the number
of possible coalitions at O(n
k
), and each coalition must be checked against each subtask
to get the coalition-to-subtask utility value. After these are calculated, the lists for each
subtask are sorted by utility so that the best coalitions are chosen first at each subtask
allocation. This total complexity is O(|T|n
k
logn
k
). This is added to the complexity of
the constraint satisfaction algorithm of the task allocation stage which was found to be
O(n
|T|k
). The allocation stage complexity dominates that of the task calculation stage,
therefore the total complexity of the MRTA algorithm is on the order of O(n
|T|k
).
34
4.5.2 Extensions
Depending on the requirements of the problem, certain extensions to this algorithm can
be made while retaining good performance. It can easily be made anytime by inserting a
timeout guard in the beginning of the search algorithm that returns the current solution
when time expires. Because the current best solution is stored for branch and bound,
this type of runtime constraint can be easily added.
If the problem requirements do not require an optimal solution but only a sufficient
one, then the algorithm can be modified to return immediately once a complete as-
signment is found. In this case the branch and bound can be removed. The runtime
complexity is still the same at O(n
|T|k
), but it will be shown in practice that this is a
significantly faster algorithm that is complete though suboptimal. Because the possible
coalitions at each step are still sorted and the best is chosen first, the algorithm’s quality
is effectively the same as the one introduced by Shehory and Kraus.
4.6 High complexity MRTA problems
The complexity of the basic solution was shown to be in the worst case O(n
|T|k
). For
problems where |T|, k, or n are large, this is still too high. A number of techniques exist
for finding solutions for each of these cases.
Given that the previous algorithm can be easily modified to be anytime, a simple
solution would be to force a fixed timeout. However by using only this modification it is
likelyonlyasmallportionofthespacewouldbesearched,sothequalityofthesesolutions
would clearly be suboptimal and incomplete.
35
Task Allocation Stage:
Task Calculation Stage:
1. Upon locating a task, broadcast the task information.
2. After a timeout period gather all the information from each robot available
to be allocated to the task.
(a) Enumerate all the possible coalitions from the replies.
(b) Calculate the utility of each coalition with respect to each subtask,
producing a list of coalition-to-subtask utilities.
(c) Group the list by subtask and sort the sublists by utility.
1. If it is past the timeout time, exit and return the best allocation found so
far.
2. If the current assignment satisfies the task and the task utility is better
than the utility of the best saved allocation, save the current allocation as
the best.
3. MRV: Determine the next subtask to allocate using the minimum re-
maining value heuristic.
4. Value selection: Iterate through the sorted list of utilities:
(a) If the current selected coalition is a valid allocation for the subtask,
append the coalition to the current assignment.
(b) Branch and bound: If the utility for current, incomplete assign-
ment is still less than the saved best assignment:
i. Forward check: Prune the space of coalition-to-subtask utili-
ties, removing coalitions and subtasks that have been allocated.
ii. Recursively call this allocation algorithm from (1) with the pruned
space.
(c) Remove the current selection, and repeat from (a)
Figure 4.5: The basic CS-MRTA search algorithm for problems of low complexity. The
Task Allocation Stage is a recursive algorithm that assigns a single subtask at each step.
The search space is the tuple of (coalition, subtask, utility) calculated in the calculation
stage. Note that the utilities in this case are inverted for branch and bound so the
algorithm is trying the minimize the utility.
36
More techniques exist such as reducing the space either before or during the search.
This is sometimes necessary but it comes at the expense of completeness. Other tech-
niques will not affect the outcome of the solution; for example, by using heuristics to help
find the best solution as soon as possible, the existing branch and bound will improve by
avoiding even more suboptimal search paths. These remaining techniques can be divided
into problem-specific methods and constraint satisfaction methods.
4.6.1 Problem-specific heuristics
Domain-specific methods can be used in situations where the problem complexity is so
high that the constraint satisfaction methods are insufficient. Knowledge about problems
was used in both [12] and [14]. Shehory and Kraus recommended combining tasks for
situations where interdependencies exist, effectively reducing the search space prior to
searchtoimproveperformance. OntheotherhandVigandAdamsusedtaskinformation
to perform constraint propagation to reduce the space during the search. These different
approaches can be divided into those that affect the initial search space and thereby
influencethesolutionqualityandcompletenessofthesolution,andthosethatimprovethe
search time without removing potentially good coalitions. The quality of these heuristics
depends heavily on the problem, therefore whether these methods in combination with
CS-MRTA should be used over other faster algorithms such as [12] cannot be discussed.
4.6.1.1 Reducing space
The actual complexity of the algorithm is dominated by |T|, k, and n, each of which
are highly dependent on the problem and therefore have some opportunity to be safely
37
relaxed though completeness will no longer be guaranteed. For the search and rescue
problem, the composition of the utility function can be exploited. If a coalition’s physical
distance to a task is strongly related to its utility, n could be reduced by bounding the
numberofrobotsconsideredforatasktosomephysicaldistance d. Thisavoidscoalitions
that will naturally have lower utilities and thus will decrease the search space. Many of
these low utility coalitions would have likely been avoided by branch and bound check,
however using this heuristic will also help reduce the unavoidable n
k
term caused by the
enumeration of possible coalition subsets.
More complex heuristics can be used to prune the initial n so that robots not likely
to be part of the best solution are will not be considered:
• Sort the robots by their utilities and choose the best n
max
robots, where n
max
is a
size low enough to be searched completely in the required time.
• Try to evenly choose the best n
max
/|T| robots for each subtask, so each subtask
will have an even number of coalitions to allocate from.
• Choose n
max
using a combination of the previous methods.
Eachoftheseheuristicswillreducentoafixedsize, n
max
howeverthebenefitofdoing
each depends heavily on the specific task and the composition of the team. Tasks with
strong dependencies – and thus complex utility functions – can interfere greatly with the
quality of simple heuristics such as these.
Reduction of |T| and k are also possible depending on the problem. If complex tasks
can be broken into smaller ones without violating any dependencies, then the pieces can
be solved independently and the overall complexity would be reduced to the size of the
38
largestindependentproblem. Thisisararecasesinceoftenimplicitconstraintsexistthat
would make the independent task allocation fail. For example consider a task that has
twohomogeneoussubtasksthathavenodependencies, andacoalition R
i
isavailablethat
hasthecapabilitytoexecuteeither. Solvingthesubtasksindependentlycouldallocate R
i
to each, but because of the single-task (ST) formulation of the problem it cannot actually
execute both at the same time.
The maximum coalition size, k, can also potentially be reduced if some knowledge
about subtasks permits, which will again reduce the search space at the expense of com-
pleteness.
4.6.1.2 Tuning utility calculation
The actual runtime of the constraint satisfaction search algorithm depends heavily on
the path taken through the search tree. Paths in which the best solution is found early
will allow the branch and bound algorithm to avoid large portions of the tree. Exploiting
informationabouttheproblemcanbeusedtohelpdirectthesearch,howeverthisrequires
that utility functions recognize information that is currently only used in the search
algorithm.
The current algorithm is biased towards choosing coalitions based on their individual
subtask utility in combination with any previously allocated subtasks. This occurs when
the coalitions for each subtask are sorted and the best is selected. This algorithm can
backfire during time-bounded searches when the only complete assignments have poor
utility and thus are at the end of the search tree. This happens because the utility
function is, as is often the case, an incomplete representation of the actual utility values.
39
This can be somewhat ameliorated by adding more information. By including holistic
ideas similar to Vig and Adams’s notion of coalition balance, hopefully better coalitions
aregivenpreference. Ideallythisnewinformationshouldrepresentanythingpertinentbut
not currently addressed by the utility function. The MRV heuristic used in the algorithm
is one example, however it approaches from a different angle – affecting the selection
of the next subtask for assignment rather than next possible coalition. The distinction
between the two is known as variable selection and value selection [8]. Variable selection
uses knowledge about the remaining subtasks to be assigned, such as choosing the one
thatismostrestrictedandthereforehardertosatisfyfirst. Thisdecreasesthechancethat
incomplete assignments will be found along the path. Value selection is used to choose
the order of coalitions to check once a subtask has been decided upon. The ideal metric
selects coalitions that will likely lead to a complete assignment earlier.
One possible value selection metric is to weight the coalitions based on their utilities
– the current method – in combination with some additional information about the state
of the system. For example, by choosing coalitions with little relevance to the other
remaining subtasks first – i.e. groups that are specialized for the current subtask – fewer
coalitions will be pruned during the forward check. This will leave more branches along
the path, which has a higher chance of finding a solution due to the larger space. A
similar idea was proposed in the solution to the degenerate example in Fig. 4.4. A simple
constant can be added to weight this new metric with the current utility values.
Since the goal of this heuristic is to choose coalitions in an order such that larger
children’s trees are search first, the method may increase the time required to find the
optimal solutions. However it may help find satisfactory answers faster, which is useful
40
when time is bounded. As an improvement, these methods can be combined with the
original algorithm into a hybrid approach: After using this heuristic to quickly find an
initial solution, the algorithm could then switch back to the original faster algorithm for
the remaining search for the optimal solution.
4.6.2 Advanced constraint satisfaction methods
In the most general case, solving constraint satisfaction problems for such constraint-
heavytasksisNP-hardifthevariables,i.e. |T|,areunbounded. Alargebodyofconstraint
satisfaction literature has been devoted to improving efficiency for when there are a large
number of variables to assign. Research has found that certain classes of problems can
be solved in polynomial time if certain conditions are present [9]:
1. The constraint graph is of a structure such that it can be decomposed into inde-
pendent problems.
2. The constraints between variables are of a particular class.
3. Properties of the subproblems are bounded such that they can be solved by tree
decomposition.
4. A combination of graph structure, types of constraints, and/or properties of the
subproblem which individually do not affect the complexity of the solution, but in
combination do.
The assumed all-different constraint makes the constraint graph complete and thus
prevents Item 1. However some properties of the problem may be able to be exploited
41
to allow such techniques. Item 2, which includes constraints that can be characterized as
constant, idempotent binary, commutative, majority, and affine functions, does not de-
scribe many of the search and rescue constraints used in this work [9]. Most precisely, the
all-different constraint is too restrictive and not within the provable classes of functions.
Item 3 is related conditions described in the following section, which will often not be
applicable. Item 4 is still an open problem and in general does not seem relevant.
Distributed and parallel algorithms have also been studied as a possible solution
to solving hard constraint satisfaction problems. Work has gone into increasing their
efficiency, however these have often required problem definitions which adhere to Items
1-3 above. Other work in the distributed constraint satisfaction field has focused on goals
for specific kinds of problems, such as solving situations where knowledge was distributed
among agents and centralizing the data at one source was undesirable [15].
Nonetheless methods such as k-consistency, or distributed methods like divide and
conquer and tree decomposition, can be used to help reduce the runtime of high com-
plexity problems.
4.6.2.1 Constraint satisfiability
Special cases of finding satisfying allocations can be recognized to be solved in less time.
If there were no subtask dependencies and no implicit resource or coalition dependencies,
the current algorithms could be solved as independent subproblems in time linear to
O(n
k
). The lack of dependencies means no conflicts will occur between assignments, and
so no pruning will be needed between subtask assignments. Therefore no backtracking
would be required. In single-task robot domains this will rarely occur. However an
42
algorithm can reuse this principle: If a task, given a list of coalitions, would require
no pruning between assignments, then satisfiability is guaranteed in time linear to the
numberofcoalitions. Thisisknownask-consistency. Forexampleifonlythe all-different
constraint exists and the members of the coalitions for each subtask are disjoint, then
the algorithm is guaranteed to find an answer in a single pass. If one is not found in the
pass, then remaining allocations need not be searched.
The pigeonhole principle is another way to use a weaker of this principle; it states
that if the amount of pruning between assignments is bounded, then an allocation can
be found in one pass. Consider the case where k = 1 and the list of coalitions for every
subtask is the same, meaning each coalition has a utility on every subtask. If n ≥ |T|,
then based on the principle, an answer will be found in one pass by matching a coalition
to each task. This idea can be extended to a more realistic problem. Again assume only
the all-different dependency exists and k = 1, but the coalition lists are not disjoint;
then if the number of subtask coalitions is greater than or equal the order of the task
when sorted by the number of allocatable coalitions, the algorithm can find a satisfactory
answer without needing to backtrack. Similarly, in these conditions if n <|T| then it can
immediately be determined that no answer exists.
This is shown in Fig. 4.6. The subtasks are sorted in ascending order by the number
ofconsideredcoalitions. Subtaskt
2
isfirstallocated,andbecausek = 1onlyonecoalition
isprunedfromeachoftheremainingsubtaskcoalitions. Thent
3
isallocated, whichagain
removes a coalition from the remaining subtasks. Because the number of coalitions for
each subtask is greater than or equal to the order of each subtask, and because k = 1,
43
Figure 4.6: Using the pigeonhole principle to guarantee fast constraint satisfaction.
then an allocation will be found in linear time. This reflects one principle: if an upper-
bound, p, can be established on the amount of pruning the selection of one subtask will
do to the space of the others, then the algorithm will find a satisfactory answer in linear
time if the number of potential coalitions for each subtask is equal to:
= (OrderedPlace(t
j
)−1)p+1 (4.1)
If only the all-different constraint exists and k = 1, then the value p = 1. This
equation can be used for arbitrary constraints if p is known and small enough, however
finding p is difficult since it depends on the ordering of the subtasks. In many cases
Equation 4.1 will not be satisfied because the p found is too large. For example the value
of p for tasks with the all-different constraint increases greatly with k because coalition
44
enumeration will naturally contain overlapping coalitions. In most cases it will be too
large with respect to the number of possible coalitions.
Amoreimportantgoalistodetermineifthereisalowerboundthatcandecideifalist
of coalition utilities is inconsistent for a given arbitrary list of coalitions and subtasks.
The p described in the examples above is an upper bound on the number of pruned
coalitions per subtask. If the exact value can be found, then Equation 4.1 can be used to
prove strong consistency [2]. Strong consistency is a property of the problem such that if
it is proven, then the problem is guaranteed to have a solution.
For example, when only the all-different dependency exists and the allocatable coali-
tions for each subtask are the same, then p is the exact amount that will be pruned
at each subtask allocation. In this problem, given complex tasks and a heterogeneous
system, few conditions arise in which p will be able to be perfectly calculated.
4.6.2.2 Divide and conquer algorithm
The following section describes a divide and conquer algorithm that can be distributed
among agents, leading to a slight improvement in runtime over CS-MRTA for certain
problems.
A simple divide and conquer algorithm for performing a constraint satisfaction search
would be as follows:
1. Decompose the task into smaller subproblems, each with w subtasks each.
45
2. Solveeachsubproblem,exceptinsteadoffindingonesolution,findallvalidcoalition-
to-subtask allocations and place them in a list. If none are found for a subproblem
return failure for the algorithm.
3. Combine the lists from each subproblem into a meta-list, which reduces the size of
the original problem to |T|/w meta-subtasks.
4. Treat the new problem as a single meta-task and solve using CS-MRTA, except use
the lists generated from Step 2 as the search space.
Assuming that there are no complex dependencies between the subproblems, then
this approach can be directly used. The lists generated by the subproblems and then
used as the search space of the meta-subtask. However the total number of nodes that
are searched in the new meta-task is equivalent to that of running the original CS-MRTA
– all valid combinations of coalitions must still be searched.
There are situations where this method can be improved. Consider a problem where
only the all-different dependency exists. After Step 1 and 2 of the algorithm above have
been run, the list of each subproblem’s coalition-to-subtask allocations has been found,
e.g. items 1-3 in Fig. 4.7a. If this list is directly used by the meta-task, there will be
unnecessarily extra information: From the point of view of the meta-task, allocation 1
and 2 from Fig. 4.7a are functionally equivalent because the knowledge of which coalition
was assigned to which subtask is at that point not needed. The meta-task only needs
whichever solution of 1 and 2 has the highest utility, because a final allocation will never
chose the coalition with lower utility over the higher.
46
This means that the list generated by each subproblem in Step 2 can be compressed
by combining the equivalent coalitions and choosing the one with highest utility. The
complexity of producing each list is that of running CS-MRTA on the smaller problem,
O(n
wk
), and the size of the list generated and passed to the meta-subtask is also of this
complexity. However the subproblem lists are compressed meaning that the final meta-
task’s search space, or more specifically the branching factor of the meta-task’s tree, is
smaller.
Figure 4.7: The decomposition of a task into two subproblems. From the point of view of
themeta-taskallocator,allocations1and2ofthemeta-subtaskareequivalent; knowledge
ofwhichcoalitionwasassignedtowhichsubtaskisunnecessarywhenonlytheall-different
constraint exists.
Whileitwasdescribedfortaskswithonlytheall-different constraint,itcanbeapplied
when other types of satisfaction and utility dependencies exist so as long as they do not
47
occur across any subproblem boundaries. For example in Fig. 4.7 if t
1
, t
2
, and t
3
also
had the same-class dependency, then the technique would still hold.
There are limitations to this approach. The constraint satisfaction algorithm run on
eachsubproblemcannolongerusebranchandboundtoavoidsolutionsthatarenotgood
enough because an exhaustive list must be generated. Therefore this technique should be
carefully considered. It is best used when branch and bound will likely have little benefit,
e.g. when there is a high probability that the original algorithm will not quickly find a
solution or when very few solutions exist. This is hard to predict but will likely occur
when the task has a small search space and a high number of constraints.
Therefore a probable use case for Divide and Conquer would be when n is low and
|T| is large. Also if there are a large number of coalitions upon which to distribute the
subproblems, then w could possibly be made very small and thus branch and bound may
not be needed. The experimental results following highlight a point in this domain at
which Divide and Conquer is no longer helpful over the original CS-MRTA algorithm.
4.6.2.3 Tree decomposition
Treedecompositionisawellregardedtechniqueforreducingruntimecomplexityinhighly
constrained CSPs. Previously it had been stated that this technique is hard to apply in
situations where dependencies are abundant, such as when the all-different constraint
exists. If the dependencies can be relaxed or avoided however, then tree decomposition
can formulate the problem such that a tree-based CSP algorithm can be used to find a
solution to the satisfaction problem in polynomial time.
48
A valid tree decomposition is described as a tree that has the following properties
[10]:
• Every subtask in the original problem appears in at least one subproblem.
• If two subtasks are connected by a constraint in the original problem, they must
appear together in at least one of the subproblems.
• If a subtask appears in two subproblems in the tree, it must appear in every sub-
problem along the path connecting those subproblems.
When these have been satisfied, a tree decomposition must be found such that the
decomposed subproblems have only one constraint between each and there are no edge
cycles, i.e. the dependency graph of the subproblems is a tree. The complexity of a stan-
dard tree-decomposed CSP is O(|T|n
w+1
), thus ideally the minimal tree-width should be
found [10]. Determining the minimal w is NP-hard, however numerous heuristic algo-
rithms exist [3]. Because of the all-different constraint this is hardly useful, however if
situationsarisewheretheconstraintisrelaxed,thenitispossiblethattreedecompositions
can be used. This is discussed later in the next chapter.
49
Chapter 5
System Design
Multi-robot coordination is often accompanied by pragmatic concerns that be addressed
in order to achieve quality results and good performance. These are not unique to this
domain, but their collection makes the problem particularly difficult. To combat the
issues commonly faced in difficult environments such as those where search and rescue
tasks are found, researchers have been focusing effort on ideas such as distributed and
fault-tolerant systems. The problematic characteristics of these environments are that
they are:
• Uncertain - Robots must deal with inaccuracies in their actuators and in this
setting this will be especially prevalent due to the unstructured environment. Also,
as the problem entails searching for victims in an unknown environment, the model
of how and where victims will be found is very hard to predict.
• Dynamic - The environment is constantly changing. Interactions between robots
and the environment will occur that will require the team be adaptable. Addition-
ally the robots’ states themselves will be changing, for example resources such as
remaining power will vary over time and therefore affect individual utilities.
50
• Failure-prone - The robots and their actions will be highly prone to failure due
to hostile conditions. In less extreme cases individual parts may break, leading to
partially functioning robots. Communication will often be delayed or fail to reach
their recipient.
The previous chapter provides a basic algorithm for MRTA for the general search
and rescue problem. This chapter will focus on how the design of the system can have
significant effects on the overall solution’s quality and performance.
5.1 Environment concerns
Many techniques have been developed with hopes of addressing the pragmatic issues of
being in a dynamic, uncertain, and failure-prone environment. Some of the design goals
that many systems have targeted are:
• Robustness - To directly handle the high rates of failure of individual systems,
bothhardwareandsoftwarecanbedesignedmorerobustlybyassumingthatfailures
will occur. Doing so will help ensure that some contingency plan will be available.
• Adaptability - Algorithms have to be designed to be adaptable. This means that
they should be general enough to be applicable to a range of problems, and that
also they should perform well these different conditions.
• Heterogeneity - A heterogeneous team or a diverse spread of resources can help
to provide both a flexible and economical system. Different types of robots are able
to address a larger range of tasks, and having expensive parts on only a portion of
51
the team can reduce costs. Also for some tasks heterogeneity is a requirement: a
task may require physically small robots while others may require large ones.
• Distributedness - By distributing the resources across robots, individual failures
willhaveasmallernegativeimpactonthesystem; providingadegreeofredundancy
can decrease the risk of complete system malfunction. Distributedness can also
be applied at an algorithmic level to allow graceful for degradation when poor
circumstances arise.
• Scalability - The algorithmic complexity for hard problems is often high. This
coupled with distributed resources can cause significant increases in complexity,
thus a useful attribute is that the algorithm should be attentive to scalability.
Examples issues include computation and communication.
Robustness, adaptability, andscalabilityaregoalsthatnearlyallclassesofalgorithms
aim to achieve, and they are especially necessary for successful robot coordination. The
remaining goals are not always pursued because they may be unnecessary or may caused
significant increases in the complexity of the solution. For example, having a heteroge-
neous team can immediately increase the search space for a problem by orders of magni-
tude. In certain problems distributedness can increase the search space and as well the
complexity of the algorithm. Each of these goals are issues that can be addressed by
proper system design.
52
5.2 Complete system
The allocation algorithm is only one part of the complete system. Fig. 5.1 shows more
details about the actual logic implemented on each robot. The CS-MRTA algorithm
encompasses the Identify and Broadcast Task and Calculate Allocation states. Other
stages address the noted concerns of complex tasks such as search and rescue, such as
the high occurrence of complete and partial robot failures as well as lost and delayed
messages.
Search
Identify and
Broadcast
Task
Calculate
Allocation
Move to Task
and Execute
Found Task
Done
Fail | Done
Fail or Done
Notify Winners
Reply with
utility
Heard Broadcast
Done
Assigned Task Start
Figure 5.1: Algorithm for search and rescue.
Distributed algorithms are usually chosen over centralized control for the reasons
of efficiency and robustness. Distributedness alone will not bring these benefits; the
algorithmsmustbespecificallydesignedthroughconsiderationofissues suchashardware
failures and system asynchronicity. The algorithm in Fig. 5.1 encapsulates some of the
issues that must be addressed.
53
Certain restrictions are applied to make the algorithm perform well under distributed
conditions. Robots that reply to new task broadcasts, which represent the n robots
considered free to be allocated to a task, are limited to robots that are not assigned to
a current task aside from searching. Robots that are calculating allocations or executing
tasks are committed to that action and unable to abort. In real situations this constraint
may need to be relaxed, however for the purposes of this research it serves to simplify
algorithm such that results can be better analyzed.
Complications due to distributedness still arise: a situation can occur when two tasks
are found and broadcast at close to the same time. Coalitions could potentially submit
their utilities on both tasks and as a result the allocators could reward their task to the
same one. To handle this there is an additional notify step after an allocation has been
found. If a coalition wins but when notified refuses, then the allocator will remove those
membersandreruntheallocationalgorithm. Anotheroptionwouldbetoreformulatethe
problem, combining the subtasks that were successfully assigned into one mega-subtask.
The allocation will be repeated with the mega-subtask already allocated, and will try to
find allocations for the remaining failed subtasks. This is a very fast algorithm similar to
constraint satisfaction techniques for partial solutions [10]. However as a consequence of
its speed, and due to the complexity of search and rescue tasks, it is not guaranteed to
be complete.
Other failures can occur in many situations. If the execution stage fails due to things
such as hardware failure, then a member of the coalition will save the task details and
re-broadcast the task some time later. Similarly if the allocator is unable to find a proper
allocation due to lack of replies or lack of committed coalitions, then the allocator will
54
save the task and retry at a later period of time. This assumes that the task failed to
find an allocation because the desired coalitions were busy. If this is not the case, i.e.
no combination of coalitions in the team could possible satisfy the task, then the task
should be removed. Recognizing this is difficult, therefore allocators can have a limit on
the number of times a task is retried for allocation. In the experiments the tasks were
randomly generated with the condition that the capability requirements were such that
thereexistssomevalidgreatercoalitiontoexecuteit. Intherealworldthiscannotalways
be controlled, therefore the system must give up after a fixed number of tries.
The search and rescue domain is a realistic and dangerous environment. Many robots
will face complete or partial failure and likewise messages will be lost and delayed. The
algorithm as presented above can already handle most of these situations. For example
if a robot malfunctions before submitting its utility or its message is lost, then its lack
of a reply will mean it will not be considered for allocation. If the robot fails during
the allocation stage, then it will not reply to the notification and thus the allocator will
attempt to re-allocate.
To combat the case where the allocator dies, robots save a list of tasks they have
submitted utilities to. If after a certain period of time the allocator does not announce a
close message representing the end of the allocation, then one of the robots will take on
responsibility of allocating the task. This can be achieved by having some initial ordering
on the robots and allowing the order of which robots rebroadcast to be based on that
ordering.
Problems can still occur that would break the performance of the system. If com-
munication or hardware failures occur at odd times, such as right before an allocator
55
broadcasts the task information or after a coalition has committed to a subtask, then
the algorithm may break. A more complete algorithm that is thoroughly tested for the
boundary cases should be considered future work.
5.3 Realistic utility functions
The choice of the utility function U
R
i
t
j
both influences and is influenced by the alloca-
tion algorithm. A coarse-grained or unrealistic utility function could make the problem
simpler, but does so at the expense of realism and therefore accuracy. A good function
should take into account as many relevant factors as possible, therefore its design is a
major part of the coalition formation problem. The overall goal of their design should be
to reflect information that will allow the best coalitions to be chosen, while not detrimen-
tally affecting the constraint satisfaction algorithm previously defined. This discussion
will discuss one utility function that meets this criteria. Many others exist, however the
actual benefit of each can only be measured per problem.
For a coalition R
i
and subtask t
j
, the utility U
R
i
t
j
is either ∅ or some value in the
domain of positive numbers. The value represents the net ability of R
i
to satisfy all
of the required capabilities of t
j
, while also taking into account opportunity costs such
as excess. For example, because all robots have a default search task as well as limited
powerreserves,anysuperfluousresourcesallocatedtoataskwouldbedescribedaswasted
resources, or excess. Some examples of this include:
• Having a coalition with a very fine-grained camera assigned to a subtask when it
is not required and a coalition with a more appropriate lower resolution camera is
56
available. In this case the excess would be defined as = c
R
i
resolution
−c
t
j
resolution
, or
the amount of extra resources that are now tied-up.
• Assigning a large coalition to a subtask when only a smaller subset of that coalition
is needed. This search and rescue domain is not super-additive, meaning adding
unnecessary resources to the coalition is wasteful and adversely affects the utility
of the global solution.
With the large number of influences in realistic utility functions, proper design has
itself become a topic of research. The following are some guidelines for creating a utility
function that addresses the issues introduced above while being compatible with the
CS-MRTA algorithm and its variants:
1. The value of one coalition, U
R
i
t
j
, should be admissible with respect to the greater
coalition, U
R
i
,R
j
,...
T
. This is similar to A* search: the utility of each subtask must
never underestimate the true utility, which is necessary for the branch and bound
optimization to work properly.
2. Extending the admissibility requirement to combinations of coalitions, utility de-
pendencies should also not be underestimated. Using the example of the weak and
strong coalition pushing a box together, U
R
i
t
j
for each should be proportional to
the larger of the utilities, c
rstrong
push
. When they are combined, adhering to the utility
dependency, the value should then be reduced to their respective values, c
r
weak
push
and
c
r
weak
push
. This prevents branch and bound from accidentally skipped bad coalition
combinations due to the presence of complex utility dependencies.
57
3. The function should be able to represent different kinds of costs such as excess
ability and excessively large coalitions.
Equation 5.1, representing the utility of coalition R
I
to t
j
, adheres to the guidelines
above. Thefunction Valuerepresentsthecalculationofthemarketvalueforthesubtask.
In this work Value(c) include information such as the distance from R
i
to t
j
. To simplify
the admissibility requirement of branch and bound, during the search the reciprocal of
Equation 5.1 is used. The variables α and β are constant penalty modifiers for excess
abilities and excess coalition size respectively. Zero or negative values resulting from this
equation represents R
i
’s lack of ability and therefore utility for executing t
j
.
U
R
i
t
j
=
|C|
X
k=1
Value(c
t
j
k
)
α(c
R
i
k
−c
t
j
k
+1)β(|R
i
|)
(5.1)
Given this utility function, the search algorithm will try to minimize the reciprocal of
the utilities for the task, represented by the value of U
R
i
,R
j
...
T
. This is calculated from the
list of coalition-to-subtask assignments and subtask dependency information. It follows
this algorithm, in which Guideline 2 is satisfied:
1. For each subtask assignment, search through the matrix of satisfaction dependen-
cies. Asatisfactionmatrixisatranslationofthetaskdependencygraphintomatrix
form such that it is easy to check if a dependency exists between a pair of subtasks.
If the assignment conflicts with another assignment in the list, return failure.
2. If all constraints are met, then for each assignment search through the utility de-
pendency matrix, similar to the satisfaction dependency matrix. If there is a de-
pendency, modify c
R
i
k
accordingly and then recalculate U
R
i
t
j
.
58
5.4 Exploiting system design
Currently the algorithm searches through a space that is defined by the resource require-
ments for the individual subtasks, the constraint between the subtasks, and the actual
robots and their capabilities. These three factors determine the size of the search space.
Adding additional information, such as the classes of robots that can execute each sub-
task,canprovidecuesthatreducethesizeofthespace,andasaresultreducetheruntime
complexity of the allocation algorithm.
Up until this point, this work has concentrated on allocating a random set of hetero-
geneous robots to a random set of tasks. In real problems the robots that are deployed
would likely be grouped into specific known classes. The robots in each class would each
have similar characteristics to the other members. This can be exploited. For example if
eachsubtaskwastobeexecutedbyaspecific class ofrobots–forexampleonebigmover,
one aerial robot, and one scout – and each robot was a member of only one class, then
the all-different constraint would dissolve because each subtask draws from a different
list of coalitions. Similarly if the coalitions vying for each subtask are disjoint, then the
allocation of subtasks could be solved independently.
In a realistic scenario, robots in different classes may able to execute a particular
subtask requirement thus a single subtask could be potentially be executed by a number
of different classes. Fig. 5.2 shows the example problem. Initially, Fig. 5.2a, the task
dependency graph is a complete graph with each edge represent the different constraint.
Because information is known about which classes are assignable to each subtask, repre-
sented by Fig. 5.2b, the constraints can be changed to a dual representation that reflects
59
the overlapping robot classes being considered for each subtask, Fig. 5.2c. This happens
to still be a complete dependency graph.
A priori design of the heterogeneous team into finer classes, those that have less
overlap of resources, could helped have prevented the dual from still being a complete
graph. Suchadesigndecisionwouldhoweverdecreasethesomeofflexibility, redundancy,
and other benefits of having a resource-distributed heterogeneous team.
Asolutiontothiswouldbetointelligentlyremoveclassesfromsubtasksatruntime. It
should be done while maintaining with high probability that a complete allocation is still
present. The process would be to first check the current tree decomposition by running
one of the polynomial time algorithms for finding a tree decomposition [3]. If the size of
the largest subproblem, w, is not acceptable, heuristics could be applied to remove some
of the constraints – i.e. by limiting the number of robot classes for a subtask.
A general principle for the heuristic should be to remove classes in a subtask if they
are already being considered in a large number of other subtasks. For example, since
class C
4
, the scout robot, is a possible candidate for all subtasks, it could possibly be
removed from consideration from subtasks t
1
and t
2
. Similar logic for other classes would
produce Fig. 5.2d, a artificially space-reduced version of the original problem. The dual
to graph (d) is (e). Many of the constraint edges have been removed in Fig. 5.2e because
it is now impossible that, for instance, t
1
and t
3
could be assigned members of the same
coalition. This dependency graph is now a tree and can be decomposed using the tree
decomposition algorithm, and then a tree-based CSP algorithm can be used to find a
solution in less time [10].
60
Figure5.2: Differentrepresentationsoftheexampleproblem. (a)Theoriginalformulation
of the problem. (b) The classes of robots, C
n
, that are assignable to each subtask are
identified. (c)Adualrepresentationof(b),wherethetruedependenciesbetweensubtasks
are identified using information from gathered from (b). (d) Artificial restrictions are
made on the classes that can be assigned to each subtask. (e) A dual representation of
the task dependency graph, where the actual subtask dependencies are now represented
by the subtask’s assignable robot classes. (f) The tree decomposition of (e).
61
This option will not always be available due to lack of information about the robot
team or insufficient information regarding the types of tasks that will be introduced.
However if they are known, then this method is a powerful way to exploit information
to reduce the number of subtask dependencies, allowing other techniques such as tree
decomposition to be used.
62
Chapter 6
Experimental Results and Analysis
The experiments were mainly performed to show the feasibility and runtime of the dif-
ferent algorithms, and as well to provide some insight into how different factors such
as n, |T|, and k affect the performance. The benefits of the actual heuristics are not
discussed as they are too problem-specific. Following these results an analysis is which
provides some logic about how the described algorithms and heuristics should be selected
depending on the actual problem.
6.1 CS-MRTA Algorithm
TheperformanceofthealgorithmswastestedinasimulatorwritteninC++. Initialtests
highlight the effects of the different constraint satisfaction techniques on search time for
a set of randomly generated tasks, seen in Fig. 6.1. Of the methods used to improve the
optimization search, the reduction gained from branch and bound is significantly higher
than other heuristics including the minimal remaining value heuristic and constraint
propagation. This is important to note as branch and bound demands much from other
63
portions of the algorithm, adding restrictions to the utility algorithm and preventing the
ability to employ a traditional divide and conquer search.
n
Figure 6.1: Test using random tasks to see the effects of different constraint satisfaction
techniques on execution time. bb refers to branch and bound, fc to forward checking,
andmrv to the minimum remaining value CSP heuristic. |T| = 3 and k = 2 in this test.
Tests were also performed to see the effects of varying n,|T|, and k. This information
is useful for determining the differing degrees of problem complexity, and can offer some
bounds at which a complete search is no longer feasible within the system’s desired time
bounds. A random set of tasks and robots were created, where each had a total of
five maximum capabilities. Fig. 6.2 shows results of varying n. The number of search
iterations showed an approximately linear increase, however more importantly the time
results fit the equation f(x) = an
b
.
Heavy costs are incurred by trying to do a complete, optimal search, as seen in Fig.
6.3. The optimal search algorithm clearly dominates the subset calculation stage over
doing a simpler satisfaction search. Results from Fig. 6.4 show that varying |T| has a
64
( a )
( b )
n
n
n
n
n
Figure 6.2: Test using random tasks to see the effects on varying n on the optimal search
algorithm, with |T| = 3 and k = 2.
65
greater influence on time as compared to increasing k. Also it shows that finding optimal
allocationsforthetestmachinewithateamsizeof n = 20islimitedtoproblemsofabout
size four.
n
Figure 6.3: Execution time of different stages of the allocation algorithm. |T| = 3 and
k = 2.
6.1.1 Failures
Allocation failures are an important metric when evaluating the performance of a MRTA
algorithm. Even when only the all-different constraint is present between subtasks, allo-
cation failures will occur, especially when n is small. This was seen in Fig. 4.4. Table
6.1 shows that failures predominantly occur when the ratio of n to |T| is low. In the
real world this will often be true: tasks will get more and more complex, or over time
the robots will become busy will tasks and the available pool of coalitions will decrease.
Thus if being unable to find an assignment even though one is present is unacceptable,
66
Figure 6.4: Execution time varying |T| and k on the complete CS-MRTA algorithm.
n = 20. When |T| was varied, k = 2. When k varied |T| = 3.
then performing a complete search is the only solution. Though CS-MRTA is slow in
comparison to known heuristic solutions, for moderately complex problems they it can
run in acceptable time.
n
Algorithm 10 11 12 13 14 15 16 17 18 19 20
S&K 11.11 8.70 7.53 5.26 1.01 1.01 1.01 1.01 1.01 0.00 0.00
CS-MRTA 1.01 0.00 2.04 1.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00
Table 6.1: Percentage of failures vs. Shehory and Kraus’s algorithm for random tasks
and robots. |T| = 3 and k = 2.
67
6.1.2 Non-random, domain-specific tasks
Little may be known about the tasks which will be introduced at the time a search and
rescue team is deployed. Many possible situations could occur that would stress the
performance and quality of the algorithm:
1. Tasks may be of high complexity.
2. The frequency of tasks is very high such that the iteration’s n – the number of
robots available at the time – is very low.
3. The resources are unevenly divided among robots in the team, therefore some
robots, for their valuable abilities, will be allocated more than others.
These situations are not mutually exclusive and will all be encountered to some de-
gree. Situation 1 was addressed by the experiments in the previous subsection. Situation
3 describes the case where n fluctuates greatly over time. Results from Table 6.1 stress
that in the situations when n is low, an algorithm that is complete will have benefits
over heuristic algorithms. This situation should occur commonly in the real world. For
example in the beginning of a search and rescue operation, most of the tasks will require
identifying possible victim sites. Some time later, after victim sites have been investi-
gate, more tasks will involve reaching the victims to confirm their status, and after that
finally administering medical aid and possible victim extraction. The resources required
for each stages differ, meaning that for a heterogeneous team, certain robots will be al-
located more often at each stage. From the point of view that tasks are instantaneously
allocated without regard to prior and future allocations, Situation 3 is actually analogous
68
to Situation 2; it is the final ratio of tasks capability requirements to the available robot
resources at the time that is ultimately important. Thus the results in Table 6.1 also
apply to Situation 2.
6.1.3 Divide and conquer algorithm
Fig. 6.5 shows the performance of the Divide and Conquer (DC) algorithm against the
optimizing CS-MRTA algorithm. Because a portion of the algorithm is distributed, the
runtimes for DC were taken by summing the runtime of the longest subproblem with the
time of the final search step. Experiments were run for problems with a fixed k = 2, and
|T| and n were varied to find the degree of benefit of the DC algorithm and to find the
point at which DC no longer helped over CS-MRTA.
Problems of size 1 ≤ |T| ≤ 10 were ran for teams of size 10 ≤ n ≤ 30 using the DC
and CS-MRTA algorithms. The subproblems for DC were of size w = 2. For problems
up to n = 16, DC was faster for the harder problems – when |T| > 6. The benefits
deteriorated for this problem set as n increased, the original algorithm became faster due
to the benefits of pruning from the branch and bound. Therefore the problem must be
carefully considered to determine which approach to use.
6.1.4 Empirical validation
The stability of the algorithm was verified using the Player/Stage simulator [6] in Fig.
6.6. Fifty tasks were submitted over a period of time to a team of twenty robots, and
all were successfully executed. The four types of tasks simulated in this experiment are
the Search, Locate, Diagnose, and Extract. Search is the default task in which robots
69
Figure6.5: Varying|T|overdifferentn’stoseetheperformanceoftheDivideandConquer
algorithm over the CS-MRTA algorithm. (a) n = 16, k = 2. (b) n = 17, k = 2.
70
begin individually searching for interesting points, i.e. evidence of possible victims. Once
evidence has been found, a multi-robot Locate task is created and allocated. The Locate
task is a directed search for a victim by a coalition of robots in a small area. If a victim
is found through Locate or Search, then either a Diagnose or Extract multi-robot task is
spawned, allocated, and then executed.
6.2 Analysis
Various techniques have been discussed in this chapter:
1. For special cases, checking the domain of values for k-consistency can guarantee
satisfiability in time linear to n
k
.
2. Using heuristics to reduce n, |T|, or k can improve the runtime of the algorithm.
3. Using value selection to search for satisfying answers sooner can aid in the case of
time-bounded search.
4. Identifying particular problems which have known tractable complexity based on
graph structure or types of constraints can allow the problems to be solved quickly
and independently.
5. Certain instances of hard problems can be solved faster using Divide and Conquer
while producing still optimal results.
6. Imposingoridentifyingclasseswithinthedomaincanbeusedtoreducethenumber
of constraints to allow for favorable tree decompositions.
71
Figure 6.6: Simulation of the algorithm in Player/Stage. Example of a Move task. In (a)
the coalition has reached a victim and by (b) have moved the victim to a safe zone.
72
Items 2 and 3 are not improvements to low complexity problems given that a com-
plete search can already be performed in acceptable time with the CS-MRTA algorithm.
However the remaining techniques can be used to further reduce the runtime, though the
cost-to-benefit ratio of implementing them in simple domains should first be analyzed.
The complete logic for applying the described techniques to a complex task can be
summarized by the algorithm in Fig. 6.7. The values |T|
max
and n
max
represent the
maximum|T|andnsizesthatareempiricallycalculatedbytheimplementertobesolvable
within the desired time limits.
6.2.1 Complexity analysis
Table 6.2 shows an analysis of CS-MRTA and previous related work with respect to com-
munication complexity, computational complexity, and solution quality. Communication
was measured as the total number of messages sent between robots during the allocation
stage. For CS-MRTA, messages are sent once from the entire team to the robot perform-
ing the allocation, and then once again to the robots that were chosen to be allocated.
For the more complicated distributed algorithms such as Divide and Conquer and tree
decomposition, more messages must be sent, however the total does not exceed O(n).
The algorithms of Shehory and Kraus and Vig and Adams did not solve for the exact
same environment as outlined in this work, e.g. they did not target high complexity
problems such as those in which the all-different constraint exists. However they are the
most relevant algorithms that have been developed.
Also, note that the analysis of each algorithms’ complexities assumes it is operating
on a complete space, but the algorithms can also be applied to spaces that have been
73
Prior: Divide robots into classes, e.g. based on their capabilities, to isolate
the true dependencies between subtasks.
1. If the problem is tree-structured:
2. Solve using the Tree Algorithm. Return.
3. Else:
4. Decompose the problem to determine w.
5. If w≤ |T |
max
and n≤ n
max
:
6. Solve with CS-MRTA. Return.
7. Else if w > |T |
max
and n≤ n
max
:
8. Solve with Divide and Conquer. Return.
9. Else:
10. If incomplete heuristics can be used:
11. Reduce the subtask classes or reduce n and/or k. Repeat from Step 1.
12. Else:
13. Solve using CS-MRTA with value selection and time bounds. Return.
(a)
Step(s) Described Section
1-2 4.6.2.4, 5.4
6 4.5
8 4.6.2.3
10-11 4.6.1
13 4.5.2, 4.6.1.2
(b)
Figure 6.7: (a) The complete algorithm for solving the ST-MR-IA MRTA problem. w is
the maximum tree width of the decomposed problem. |T|
max
and n
max
are the max sizes
solvable by the system within the time limits. (b)
74
pruned a priori using heuristics. In these cases their optimality and completeness are no
longer in the global sense but rather with respect to that particular space.
Algorithm Comm. Computation Solution Quality
Shehory and Kraus O(n
k−1
) O(n
k
) Good but incomplete
Vig and Adams O(n
k−1
) O(n
k
) Good but incomplete
CS-MRTA Algorithm O(n) O(n
|T|k
) Optimal and complete
a
Divide & Conquer O(n) O(n
|T|k
)
b
Optimal and complete
c
Tree Decomposition O(n) O(|T|n
k(w+1)
)
d
Good and complete
a
Optimal and complete where there is no time bound.
b
There is a factor of speedup that is dependent on |T| over the simple approach, however the absence
of branch and bound in this algorithm means that for certain problems the algorithm may under perform
CS-MRTA.
c
Optimal and complete where there is no time bound.
d
w is the width of the largest subproblem.
Table 6.2: Analysis of different approaches to the ST-MR-IA problem with respect to
communication, computation, and quality.
6.2.2 Algorithmic results
Many of the original goals have been satisfied, an optimal algorithm for MRTA of hetero-
geneous teams to complex tasks was introduced. When the problems get too complex, a
number of heuristics and advanced constraint satisfaction techniques can be used. The
overall system also met the stated goals:
1. Distributedness and heterogeneity were used at the outset from which the
algorithms were developed.
2. Adaptabilitywasachievedbyusinggeneral,well-understoodtechniquesforsolving
search problems, namely the constraint satisfaction formulation.
3. Robustness is present through the pragmatic system design. Contingency plans
and graceful degradation are present for the many possible points of failure.
75
4. Scalability and efficiency are more subjective. Complete search incurs the ex-
pense of increased computation. However the algorithms are still tractable. Also
communication was kept at low complexity.
76
Chapter 7
Conclusion
This work has presented a complete and optimal method for multi-robot task allocation
of complex tasks to heterogeneous teams. This was achieved by first describing the
properties of environments that have complex tasks and how to go about modeling them.
Certain trade-offs were made regarding the precision at which they should be modeled;
the most important factors were identified and used.
From this a basic constraint satisfaction algorithm was used to determine the actual
allocation, and experiments and analysis were performed to reveal that for such tasks
it is possible to achieve completeness and optimality. For more difficult problems, more
complex techniques were introduced that exploited more information about the problem
such as the types of subtasks and composition of the team. Also advanced constraint
satisfactiontechniquessuchask-consistencyandtreedecompositionwereused,andanew
Divide and Conquer algorithm was introduced that benefit specific instances of complex
problems. A launching point was also defined for the possible domain-specific heuristics
that could be used to improve performance, although determining the correct course of
action requires more insight into the actual problem.
77
The basic algorithm, along with a thoroughly designed utility function, was placed
inside an actual system and validated in simulation. They proved to be robust to failures
and scalable in important metrics including runtime and communication complexity.
7.1 Future Work
Many issues still remain in the general problem of coalition formation for heterogeneous
multi-robot teams, however this work has helped to identify some of the critical issues to
their proper design. A likely scenario is that harder tasks than those described here will
be applied to robots, meaning more algorithms must be developed. Heuristics will likely
be used and therefore a significant amount of analysis should be done to discover the
actual implications of applying the prescribed heuristics. This is best done by isolating a
concrete task and identifying and testing the performance and solution quality impacts
of the techniques.
Also a direct comparison between CS-MRTA to current approaches, such as Shehory
andKraus[12]andVigandAdams[14], foraspecificproblemshouldbedonetoquantify
the actual benefits of optimality and completeness. The goal should be to isolate the
differences beyond the failure rates that were described in this work by performing a
long-termsimulationforeachalgorithmandmeasuringmetricssuchasthetimetoresolve
each task and overall execution time. This will provide more insight into the algorithmic
trade-offs.
This was a preliminary investigation into using constraint satisfaction algorithms to
solve the MRTA problems, therefore many restrictions were in place so that the specific
78
techniques could be isolated and tested. By relaxing some of these constraints, a more
complex but better performing system could be designed. For example robots that were
already assigned to tasks were barred from replying to task broadcasts. There could
definitely be cases in which it would be of higher global utility to reassign the busy robot
to a new task, and possibly replacing its role with another. This falls within the realm
of coalition formation and is an important problem needing more research.
79
References
[1] J.CasperandR.Murphy. Human-robotinteractionsduringtherobot-assistedurban
search mid rescue response at the world trade center. In IEEE Transactions on
System, Man, and Cybernetics, volume 33 (3), pages 367–385, 2003.
[2] R. Dechter. From local to global consistency. In Artificial Intelligence, volume 55
(1), pages 87–108, 1992.
[3] R. Dechter. Tractable structures for constraint satisfaction problems. In Handbook
of Constraint Programming, chapter 7, pages 209–241. Elsevier, 2006.
[4] B.P.GerkeyandM.J.Mataric. Sold!: auctionmethodsformultirobotcoordination.
In Robotics and Automation, IEEE Transactions on, volume 18 (5), pages 758–768,
2002.
[5] B. P. Gerkey and M. J. Mataric. A formal analysis and taxonomy of task allocation
in multi-robot systems. In Intl. Journal of Robotic Research, volume 23 (9), pages
939–854, 2004.
[6] B. P. Gerkey, R. T. Vaughan, and A. Howard. The player/stage project: Tools
for multi-robot and distributed sensor systems. In Proceedings of the International
Conference on Advanced Robotics (ICAR 2003), pages 317–323, 2003.
[7] H. Noda et al. H. Kitano, S. Tadokar. Robocup-rescue: Search and rescue for large
scaledisastersasadomainformulti-agentresearch. InIEEE Conference on Systems,
Man, and Cybernetics, pages 739–743, 1999.
[8] R. Haralick and G. Elliot. Increasing tree search efficiency for constraint satisfaction
problems. In Artificial Intelligence, volume 14 (3), pages 263–313, 1980.
[9] P.Jeavons, D.Cohen, andM.Gyssens. Closurepropertiesofconstraints. In Journal
of the ACM, volume 44 (4), pages 527–548, 1997.
[10] S. J. Russell and P. Norvig. Artificial Intelligence: A Modern Approach, pages 137–
160. Prentice Hall, 2 edition, 2002.
[11] P.Scerri,A.Farinelli,S.Okamoto,andM.Tambe. Allocatingrolesinextremeteams.
In in Proceedings of AAMAS’04, Poster Presentation, pages 1502–1503, 2004.
[12] O. Shehory and S. Kraus. Methods for task allocation via agent coalition formation.
In Artificial Intelligence, volume 101 (1-2), pages 165–200, 1998.
80
[13] R. G. Smith. The contract net protocol: High-level communication and control in a
distributed problem solver. In IEEE Transactions on Computers, volume C-29 (12),
pages 1104–1113, 1980.
[14] L. Vig and J. A. Adams. Issues in multi-robot coalition formation. In L. E. Parker,
editor, Multi-Robot Systems: From Swarms to Intelligent Automata, volume3, pages
15–26, 2005.
[15] M. Yokoo, E. H. Durfee, T. Ishida, and K. Kuwabara. The distributed constraint
satisfaction problem: Formalization and algorithms. In Knowledge and Data Engi-
neering, volume 10 (5), pages 673–685, 1998.
81

Abstract (if available)

Abstract Coalition formation has become a relatively important subset of multi-robot task allocation of heterogeneous teams. The problem involves allocating subsets of a team, called a coalition, to the subtasks within tasks. In this work, tasks come from complex domains in which there exist many interdependencies between the subtasks. Many aspects of coalition formation in this setting will be studied with the goal of deciphering the algorithmic and system design necessary to achieve both good performance and accurate results.

Linked assets

University of Southern California Dissertations and Theses

Conceptually similar

PDF

Macroscopic approaches to control: multi-robot systems and beyond

PDF

Motion coordination for large multi-robot teams in obstacle-rich environments

PDF

A robotic system for benthic sampling along a transect

PDF

Auction and negotiation algorithms for cooperative task allocation

PDF

Robust loop closures for multi-robot SLAM in unstructured environments

PDF

Decentralized real-time trajectory planning for multi-robot navigation in cluttered environments

PDF

Managing multi-party social dynamics for socially assistive robotics

PDF

Multi-robot strategies for adaptive sampling with autonomous underwater vehicles

PDF

Target assignment and path planning for navigation tasks with teams of agents

PDF

Machine learning of motor skills for robotics

PDF

Effectiveness of engineering practices for the acquisition and employment of robotic systems

PDF

Predicting mission power requirement for mobile robots

PDF

Adaptive sampling with a robotic sensor network

PDF

Algorithms and systems for continual robot learning

PDF

The interplay between networks and robotics: networked robots and robotic routers

PDF

Mobility-based topology control of robot networks

PDF

Self-assembly and self-repair by robot swarms

PDF

Bayesian methods for autonomous learning systems

PDF

Robot life-long task learning from human demonstrations: a Bayesian approach

PDF

Efficient and effective techniques for large-scale multi-agent path finding

Asset Metadata

Creator Su, Charles (author)

Core Title Coalition formation for multi-robot systems

School Viterbi School of Engineering

Degree Master of Science

Degree Program Computer Science (Robotics

Publication Date 08/08/2007

Defense Date 08/01/2007

Publisher University of Southern California (original), University of Southern California. Libraries (digital)

Tag multi-robot coordination,OAI-PMH Harvest

Language English

Advisor Koenig, Sven (committee chair), Lerman, Kristina (committee member), Sukhatme, Gaurav S. (committee member)

Creator Email charlees@usc.edu

Permanent Link (DOI) https://doi.org/10.25549/usctheses-m778

Unique identifier UC1490717

Identifier etd-Su-20070808 (filename),usctheses-m40 (legacy collection record id),usctheses-c127-536107 (legacy record id),usctheses-m778 (legacy record id)

Legacy Identifier etd-Su-20070808.pdf

Dmrecord 536107

Document Type Thesis

Rights Su, Charles

Type texts

Source University of Southern California (contributing entity), University of Southern California Dissertations and Theses (collection)

Repository Name Libraries, University of Southern California

Repository Location Los Angeles, California

Repository Email cisadmin@lib.usc.edu