1 Introduction
Collision avoidance is a central problem in various multiagent path planning applications, and the problem has been provided different solutions in different paradigms [32, 7, 10, e.g.]. In this paper, we focus on multiple dynamically arriving and independently controlled robots to move from their source to their destinations using a track network [17, 4, 40]. As many robots share the same track network, they are prone to collide with each other. To avoid that, three different approaches are employed in the literature.
In the first approach, offline multirobot planning algorithms are employed to generate the collisionfree paths for all the robots statically [13, 35, 41, 34, 38, 28, 29, e.g.]. However, this approach has two severe drawbacks. First, the computation time for generating path plans for a large number of robots may be prohibitively large. Second, they cannot deal with the dynamic arrival of new robots to the system without recomputing the whole plan.
In the second approach, the robots independently generate their trajectories offline without the knowledge about the trajectories of the other robots [2, 8, 20, 24, 23, 19, 25, 36, 32, 11, 7, e.g.]. Hence, the trajectories of the robots are not collisionfree, but are resolved online in a decentralized manner through information exchange among the potentially colliding robots, assuming that the robots will cooperate with their movements. If the simultaneous movements of the robots are not possible, the robots run a distributed consensus algorithm to find a collisionfree plan.
In the third approach, robots interact in an auctionlike setting and bid for their makespan or demand for resource [21, 3, 22, 6]. Algorithms are designed for certain optimality objectives. However, these approaches do not allow robots to be owned and controlled by independent agents, and therefore do not ensure that these agents bid their privately observed information (makespan or demand of resource) truthfully to each other or to the planner. However, the combinatorial auction reduction of the MAPF problem [1] does satisfy truthtelling, but it is centralized and therefore has the same limitations of time complexity and dynamic arrival. The other strand of literature [33, 12] on noncooperative robots consider other robots as dynamic obstacles and solve computationally hard mixed integer programs in a centralized manner.
We note that in many commercial settings the robots are controlled by independent operators, e.g., in autonomous vehicle movements, and the robots can potentially manipulate their bids for a prioritized scheduling. In this paper, we exploit the full strength of mechanism design to ensure truthtelling along with other desirable properties like collision and deadlock avoidance.
Our Approach and Results
We propose a decentralized mechanism for a group of robots that move on a shared workspace avoiding collision with each other. A collision situation arises when multiple robots try to simultaneously access a common location. The competitive robots in our setting engage in a spot auction and bid the amount they are willing to pay to get access to those locations. In our protocol, the robots that ‘win’ the auction get access to move, but for a payment. The challenge in designing such a protocol is to choose the winners and their payments such that the robots provide their private valuations for the access locations truthfully.
To this end, we consider a quasilinear payoff model [31, Chap 10] for the robots and propose SPot Auctionbased Robotic Collision Avoidance Scheme (SPARCAS). We show that SPARCAS is decentralized, collisionfree, deadlockfree, and robust against entryexit (Claim 1). The mechanism ensures that every competitive robot reveals its private information truthfully in this spot auction (Theorem 1), does not have a positive surplus of money, and is locally efficient (Theorem 2).
We run extensive experiments in §6 to evaluate the performance of SPARCAS in practice. We show that SPARCAS (1) scales well with large number of robots, (2) takes much less planning and execution times compared to that of M* [38] and prioritized planning [35], (3) does differentiated prioritization of different classes of robots, and (4) handles dynamic arrivals smoothly.
2 Problem Setup
Define . Let be the set of robots that are trying to travel from their sources to destinations in a decentralized manner over a graph , where is the vertex set and is the edge set. All edges represent fullduplex paths, i.e., robots can travel on both directions on this edge following usual traffic rules. Time is discrete and is denoted by the variable . Every edge in the graph is partitioned into slots where a robot can stand at any given time step. Every slot is uniquely numbered between , where is the total number of slots. We represent the th slot by , . We call every vertex having a degree of three or more an intersection point, since robots moving into such vertices cannot guarantee to avoid a collision without coordinating with each other. In practice, an actual intersection will be a roundabout having a fixed number of slots. Every roundabout can hold robots equal to the number of slots at any given time and the movement of all the robots is unidirectional (e.g., counterclockwise). An illustration of the paths and the roundabout is given in Figure 1. A vertex with degree larger than four can be equivalently represented using a larger roundabout that can accommodate that many number of fullduplex paths.
We assume that these robots are independently controlled (or owned) by agents who have no information about other robots’ locations, sources, and destinations. Each robot has a deadline to reach its destination, which contributes to its value at each time step, e.g., monetary gain from the transfer of a shipment to a customer. A necessary goal of this traversal is to ensure that no collision occurs between the robots.
In a decentralized traversal plan of the robots, every robot decides its path based on its local information, e.g., those received through its own sensors and shared by other robots in close proximity. Let the path of robot be denoted by , where ’s are the slots of the graph leading from the source to the destination of . When two different robots reach the same slot at the same time, a collision occurs, which each robot wants to avoid. Collision can occur (a) at a roundabout where two robots intend to move to the same empty cell, or (b) on a cell in the edge where a robot is stationary and another robot moves into the same cell. Let the current location of robot at is denoted by , and the next intended location is .
We assume that a robot’s value is calculated internally by the entity that controls it by considering several factors, e.g., its proximity to the deadline, the type of objects it is carrying (high, if it is carrying a priority shipping item), and all such factors are consolidated into a real number for robot if it can move to its next location at time . The value is zero if the robot does not move at .^{1}^{1}1We assume this for simplicity of the exposition. However, our algorithm works even when the value is nonzero and has the same time complexity.
In this paper, our primary objective is to find a decentralized mechanism that (a) uses the current and intended location of the nearby robots and ensures truthful revelation of their valuations, (b) avoids collision, deadlocks, (c) maintains fairness by prioritized scheduling based on higher willingnesstopay. We assume that the robots are capable of communicating with each other within close proximity and can compute their plans of movement. These objectives are formally defined in Section 4.
3 Decentralized Mechanisms
We develop decentralized mechanisms that avoid collision dynamically using the principles of mechanism design theory [5]. We provide two mechanisms and show how the latter improves the performance even though both of them avoid collision. Every decentralized mechanism discussed in this section is preceded by a computation of the shortest path from the source to destination for every robot.^{2}^{2}2There are several polynomialtime algorithms to compute such a path [18, e.g.], and we therefore exclude this part from our description of the mechanism. We will, however, include the path computation time in the empirical evaluation to make a fair comparison with other collisionavoidance mechanisms.
In the current setup, exactly two robots can engage in a collision scenario. A first approach to avoid collision is to develop a protocol where each robot can independently calculate a plan and move according to it. The mechanism emerging from such decentralized planning has to ensure that multiple robots do not appear at the same cell simultaneously.
Since, each robot has a value at every time step , we want the mechanism to yield a decentralized plan for the robots such that it maximizes the sum of their values. Hence, this mechanism is economically efficient^{3}^{3}3In microeconomic theory, the alternative that maximizes the sum of the values of all the agents is called ‘efficient’, and it is known that it gives rise to a lot of other desirable properties. For a complete discussion, see [5]. [31, Chap 10]. In the rest of the paper, we will use the term ‘efficient’ to denote an allocation that maximizes the sum of the valuations of the agents. If the robots find out that they are leading to a collision, they share information of their values, e.g., for robot , and an efficient plan of movement is decided to allow the robot with a higher value to move and the other to wait – breaking ties arbitrarily. We provide a formal definition of ‘efficiency’ in Section 4.
Our first approach is a naïve decentralized mechanism, shown in Algorithm 1 at time for robot (the mechanism is repeated at every for every until each robot reaches its destination).
Note that the other robot that may collide with, i.e., has or , must be close to robot and therefore can communicate with to announce its current and next cell.
This mechanism is efficient given the value information, i.e., ’s, of the agents at every are accurate. Since the robots in our setup are independently controlled, these information are private to the agents. Collision mitigation in such scenarios needs a mechanism that selfenforces the agents to reveal it truthfully. This is important in a setting with competing robots, where a robot can overbid its value to ensure that it is given priority in every collision scenario. The naïve mechanism in the current form would fail to ensure efficiency if it uses only the reported values since the strategic robots will overbid to increase their chance of being prioritized.
This is precisely where our approach using the ideas of mechanism design [5] is useful. In mechanism design theory, it is known that in a private value setup, if the mechanism has no additional tool to penalize overbidding, only degenerate mechanisms, e.g., dictatorship (where a preselected agent’s favorite outcome is selected always), are truthful [15, 30]. This negative result also holds in the robot collision setting since the GibbardSatterthwaite result extends to settings with cardinal values as well. A complementary analysis by Roberts [27, Thm 7.2] shows that a dictatorship result reappears under certain mild conditions in a quasilinear setting (which is our current setting and is formally defined later), unless monetary transfers are allowed. Money, in these settings, is used as a means of transferring value from an agent to another, and it is shown to help by unraveling the true values of the agents. In this paper, we, therefore, use monetary transfers among the agents to ensure truthful value revelation at every round.
Robot payoff model: At every time step , given the current position of the robots, denote the set of feasible nexttime step configurations by . Hence, for every feasible configuration , robot ’s valuation is given by if robot is allowed to move to under , and zero otherwise. The mechanism also recommends robot to pay amount of money – which can be negative too, meaning the robot is paid. The net payoff of robot is given by the widely used quasilinear formula [31, Chap 10]
(1) 
A strategic robot reports its private information to maximize its net payoff. We assume that the robots are myopic, i.e., consider maximizing their immediate payoff. A mechanism in such a setting is defined as follows.
Definition 1 (Mechanism)
A mechanism is a tuple which decides the allocation and payment for every robot at every time step . Here the allocation function at time is given by that decides the next location of every robot , and denotes the payment made by the robot. Hence, and denote the allocation and payment of robot respectively at time step .
We assume that the robots agree to a mechanism and compute them locally and follow the movement given by and pay according to to a central authority. In this paper, we consider allocation and payment functions to be stationary, i.e., independent of .
Under this setup, the naïve decentralized mechanism (Algorithm 1) can be made truthful by adding the following payment rule. The robot that is prioritized pays the amount equal to the bid of the robot that stops at that time. This is the wellknown second price auction [37], which is known to be truthful, and we run this at every instant and for every potentially colliding pair of robots.
We notice that in Algorithm 1, the robots do not simultaneously move to the same cell and therefore successfully avoid collision in a decentralized manner. However, this mechanism can lead to the following deadlock scenario. Suppose the intersection is of four fullduplex paths with four cells at the intersection (Figure 2). If there are two robots at the intersection and two more are attempting to enter, and both the entering robots wins the auction step (Step 8) in Algorithm 1, it will lead to the four cells at the intersection occupied with four robots. If these robots’ next locations are the current locations of the robots already in the intersection, none of them can move under this mechanism (see Figure 2).
To avoid such a deadlock, a mechanism cannot allow more than robots to enter an intersection of capacity . Our proposed decentralized mechanism SPARCAS (SPot Auctionbased Robotic Collision Avoidance Scheme) considers the quasilinear payoff model, takes account of the known facts of mechanism design, and modifies the naïve mechanism to avoid such a deadlock along with other desirable properties. For a given graph , let the set of indices of the intersection vertices be represented by . Denote the cells of intersection vertex by . SPARCAS modifies how the robots enter an intersection. At every time step , for intersection , it finds the set of robots that are either inside the intersection or are attempting to enter the intersection. From the information shared by all the robots , the mechanism allows every robot to find the feasible nextstep configurations at that intersection. The feasible configurations ensure that there are no more than robots in the intersection of capacity . The set of feasible nextstep configurations is an union of the individual feasible configurations at each intersection . At the nonintersection cells, every robot advances to a cell in its shortest path unless that is already occupied by robot – we keep these configurations out of the allocations (e.g., ’s) since we do not need a collective decision there. The proposed mechanism picks the configuration
(2) 
The configuration maximizes the social welfare (sum of the values of all the agents) of all the robots that are either inside or are entering the intersection. Denote this configuration by . Similarly, we can define a welfare maximizing configuration excluding robot as follows.
(3) 
This choice maximizes the social welfare of all the robots except . Denote this configuration by . Define the following expression for payment
(4) 
We are now ready to present our proposed mechanism SPARCAS. For agent at time , it is described in Algorithm 2. As before, the mechanism is repeated at every for every until each robot reaches its destination.
Algorithm 2 describes the mechanism from the individual agents’ point of view. The consolidated payment collected by the trusted authority at intersection at from all the robots at that intersection is distributed equally to the robots that were not part of intersection at . Therefore, SPARCAS does not accumulate money from the agents.
Locally centralized via intersection manager: SPARCAS does not need any synchronization among the robots except that they all follow a common clock (which is also a standard assumption in robot collision avoidance literature [38, 39, 35, e.g.]). Yet, in Section 5, we show that it satisfies many desirable properties. However, there is some computational redundancy in SPARCAS. Step 11 of Algorithm 2 is computed by every robot involved in the mechanism near an intersection point, and this makes the mechanism completely decentralized. A presence of an intersection manager (a trusted intermediary) at who can collect the reported and compute it once and inform all the robots in could substantially reduce the cost of computation of every robot. Though this will come at a slight compromise in the decentralized feature of SPARCAS, we want to make the reader informed about both the versions of the mechanism.
In the following section, we define certain desirable properties for decentralized robot collision avoidance schemes and show that SPARCAS satisfies all of them.
4 Design Desiderata
In a decentralized robot path planning, the agents choose their own route from the source to the destination. The collision avoidance mechanism ensures a protocol that is applied locally at a potential colliding scenario. The property desirable in such a setting is of locally efficient prioritization.
Definition 2 (Local Efficiency)
A robotic collision avoidance mechanism is locally efficient if for every time , every intersection , it chooses an allocation that maximizes the sum value of all the robots. Formally, it picks
However, in a multiagent setting, ’s of the robots are unknown to the mechanism, which can only access the reported values ’s. Therefore, the following property ensures that the robots are incentivized to ‘truthfully’ reveal these information.
Definition 3 (Dominant Strategy Truthfulness)
A mechanism is truthful in dominant strategies if for every , ^{4}^{4}4We use the subscript to denote all the agents except agent , therefore, ., and
The inequality above shows that if the true value of robot is , the allocation and payment resulting from reporting it ‘truthfully’ maximizes its payoff irrespective of the reports of the other robots.
Since we consider mechanisms with monetary transfer, an important question is whether it generates a surplus amount of money. The following property ensures that there is neither surplus nor deficit.
Definition 4 (Budget Balance)
A mechanism is budget balanced if for every and , .
In the context of decentralized robot path planning, a mechanism that is robust against robot failures is highly desirable. Also, it is desirable if a robot can start its journey when other robots are already in motion, and the mechanism does not need other robots to recompute their path plan.
Definition 5 (EntryExit Robustness)
A mechanism is robust against entry or exit of the robots if the properties satisfied by the other robots’ path plans are unaffected by an addition or deletion of a robot under the mechanism.
Centralized collision avoidance mechanisms that compute the paths and recommends that to all the robots are not robust against entry or exit. With every addition or deletion of a robot, the plan has to be recomputed. It is to be noted that decentralization alone cannot guarantee entryexit robustness. Decentralization only implies that the decisions are taken independently by each of the robots. It does not restrict the way in which they interact with each other. Based on the interaction, the plan may not be robust against entryexit, as the following example shows.
Example 1 (Decentralized but not EntryExit Robust)
Consider the following decentralized version of the prioritized planning algorithm. Before beginning to move, the robots send their identities on a common channel (assume that there is a wired broadcast channel connecting all the starting positions), but this common channel is not available when they are on the move. The highest priority robot computes its path and broadcasts it (the priority order is fixed beforehand and is a common knowledge of all the robots). After listening to that plan, the second highest priority robot plans its path considering the former as a dynamic obstacle and broadcast, and the process continues for robots of the next priorities. After all robots compute their plans in this decentralized manner, they leave their parking slots and follow their predecided (but decentralized) plan of movement. This scheme is clearly not robust against entryexit. A newly joined robot does not have the earlier broadcast messages and hence cannot plan its path. Also if that robot has a higher priority than some of the robots that are moving already, then those lesser priority robots cannot change their path plan.
In the following section, we show that our proposed mechanism satisfies all these properties. In Section 6, we consider a real warehouse setting and exhibit the performance of SPARCAS in practice.
5 Theoretical guarantees
The property of truthfulness is important in the multiagent setting since it ensures that the allocation decision is taken on the true values of ’s and the actual locally efficient allocations were done.
Theorem 1
SPARCAS is dominant strategy truthful.
Proof: This proof is a standard exercise in the line of the proof for VickeryClarkeGroves (VCG) mechanism [37, 9, 16]. SPARCAS follows the VCG allocation and payment locally at every intersection calculated by the robots independently. Hence, the payoff of robot at intersection is given by (for brevity of notation, we hide the time argument in every function and write as )
The first equality is obtained by writing and reorganizing the expression for . The inequality holds since by definition for every ; in particular, we chose . The last equality is obtained by reorganizing the expressions again.
SPARCAS redistributes the generated money from a particular intersection to the robots who are not part of it at that time step (see the paragraph following Algorithm 2). Clearly, this does not affect the truthfulness properties. The generated surplus before redistributing can be shown to be always nonnegative.^{5}^{5}5The intuition for this claim is that absence of a robot reduces congestion, which leads to the other robots being allowed to move. This increases the sum of the values of the other robots. Therefore, we skip a formal proof of this fact. The allocation of SPARCAS, given by Equation 2, maximizes the social welfare at every intersection. Therefore, it is locally efficient. Hence we get the following theorem.
Theorem 2
SPARCAS is budget balanced and locally efficient.
SPARCAS satisfies certain properties by construction. The following claim summarizes them and we explain it below.
Claim 1
SPARCAS is decentralized, collisionfree, deadlockfree, and robust against entry or exit.
In SPARCAS, each robot near an intersection point does message passing, compute the allocation and then move synchronously according to it. Each of the robots at an intersection computes the same allocation which keeps one block in the intersection empty (see the definition of the allocation set ). Thus the robots avoid collision and deadlock, and the mechanism is completely decentralized.
Note that SPARCAS depends only on the values reported by the robots that are already in an intersection or are about to enter it. A newly entered robot can at most take part in such an interaction, but cannot change the way other robots in other intersections interact with each other. Hence, the properties that those robots were satisfying before the entry of this robot continue to be satisfied. Hence we get the claim.
In the following section, we investigate the performance of SPARCAS in realworld scenarios.
6 Experiments
While SPARCAS satisfies several desirable properties of a collision avoidance mechanism, its scalability, time complexity to find a collisionavoiding path, and differentiated treatment with different classes of robots are not theoretically captured in the previous sections. This is why an experimental study is called for. Note that the mechanisms that fall in the third set of approaches in §1 either only use the bidding part of the auctions and not the payment which is essential to guarantee truthfulness in an auction [21, 3, 22, 6] or is a reduced combinatorial auction of the centralized algorithm [1]. Either way they are incomparable with SPARCAS, which is truthful and decentralized. We compare SPARCASwith two widely used protocols for multiagent path finding – (a) M* [38]: optimal, but has a significant time complexity, and (b) prioritized planning [35]: suboptimal, but has low time complexity.
To evaluate SPARCAS experimentally, we use a 2D rectangular workspace representing a road network. An example of such a workspace of size is shown in Figure 4. A robot picks and delivers an object from and to a cell in the service area. Each robot follows the traffic rules in the road network, and moves along with the directions of the arrows from the source to the destination. It can change its direction only within an intersection cell, but its options are restricted by the available traffic directions in that particular intersection cell.
We have implemented SPARCAS in Python.^{6}^{6}6All codes are available at https://bit.ly/2lx0fHk The simulations have been performed in a 64bit Ubuntu 14.04 LTS machine with Intel(R) Core TM i74770 CPU @3.40 GHz 20 processors and 128 GB RAM. Each run for a specific number of robots and the workspace size is performed 20 times to calculate the average of the result. The source and goal locations of the robots are selected independently and uniformly at random from the cells of the service area.
A robot is generated uniformly at random from one of the three classes: economy, regular, premium having weights , , and respectively.^{7}^{7}7Weights are increasing with a rough multiplying factor of . At every time instant of the experiments, the valuation of a robot entering an intersection is assumed to be , where is the wait time of the robot till that instant and is the weight as described above.
6.1 Scalability
We evaluated the scalability of SPARCAS on workspaces of four different sizes: , , and ,^{8}^{8}8These numbers ensure a regular pattern of the workspace of Figure 4. and for different number of robots between and . Figure 4 shows how the computation time of SPARCAS varies with the number of robots and the size of the workspace. The computation time of SPARCAS has two components: (a) time for an offline path computation and (b) the time required to run the spot auctions (given by Algorithm 2) online. In our experiments, we assumed that the robots compute their paths to reach the destination using A* algorithm [18]. As this computation can take place in parallel, we count the maximum of the plan computation times for all the robots as the offline computation time (part (a)). We assume that each plan execution slot is preceded by a minislot when the auction can take place at any intersection. We take the product of the duration of the minislot dedicated for auction and the maximum number of steps to finish the plan execution for any robot (the makespan) to find the total time spent in spot auction (part (b)). The duration for the minislot has been decided based on extensive simulation with different reasonablysized workspaces and robot populations.
6.2 Comparison with static multirobot planning algorithms
We compare the performance of SPARCAS with that of M* [38] and prioritized planning [35], two stateoftheart multirobot path planning algorithms. The original version of M* ensures the optimality of the generated multirobot plan in terms of the total cost (sum of the time for all the robots to reach destination). However, a variant of M* called inflated M* can produce a suboptimal plan faster than the original M*. We compare SPARCAS with inflated M* too. The prioritized planning algorithm also does not provide any optimality guarantee, but can generate collisionfree paths much more timeefficiently than both versions of M*.
We compare SPARCAS, M*, inflated M*, and prioritized planning for a workspace and different number of robots upto 500 robots. We have set a timeout of . If the computation does not finish before the timeout, we consider the timeout duration as the computation time of the algorithms (which is a lower bound). The experimental results are shown in Figure 6. The lines connect through the average values of the planning times, while the actual planning times for runs for every number of robots are scattered according to their values in the figure. The results show that SPARCAS outperforms all the other three algorithms in terms of computation time. M* and inflated M* algorithms do not scale beyond 75 robots for this timeout.
We also compare the makespan (maximum time among all robots to reach destination) and average path execution time (the average of the individual path lengths) for the mechanisms for a workspace of size in Figure 6. The method of the plot is identical to Figure 6. The numbers on top of the bars show the percentage of successful completion (not hitting timeout). The results show that there is not much difference in the execution part of these mechanisms and that SPARCAS provides a path which is very close in length to that of the optimal path generated by M*.
6.3 Delays of different priority classes
We compare how long robots of different classes (economy, regular, and premium) take to reach their destinations. The first and second subplots of Figure 7 show the average waiting times and payments respectively of the different classes of robots for a workspace size of . We see that for a reasonable congestion, SPARCAS prioritizes the higher classes for a greater payment.
6.4 Experiments with ROS
We have simulated SPARCAS for up to 10 TurtleBots [14] on ROS [26]. We have used a workspace of size (similar to Figure 4) with each grid cell of length . The linear and the angular velocity of the TurtleBots have been chosen in such a way that each motion primitive takes for execution. The maximum time for running an auction (decides the length of a minislot) observed in all our experiments is about . The video of our experiments is submitted as a supplementary material.
We also ran experiments to find out (a) the payments under SPARCAS, and (b) the capability to handle dynamic arrival of robots. The payments are sufficiently small and the dynamic arrivals are gracefully handled in SPARCAS. The details of these experiments are in the supplemental material.
6.5 Capability of handling dynamic robot arrival
In this section, we study the robustness of SPARCAS against dynamic robot arrivals. The setup remains similar to the previous subsection – we mention the differences as follows. We partition the total number of robots into two groups of equal size for this evaluation. The first group of robots arrive at the beginning. The rest of the robots arrive independently and uniformly at random within the time interval of zero and the length of the workspace. In SPARCAS, a newly arrived robot computes its own path by using the A* algorithm [18], and starts to follow that path immediately. However, in M*, a newly arrived robot requests path to the centralized M* path planner. The M* planner collects such requests and waits for replanning until the number of the newly arrived robots exceeds a predefined threshold. In our experiments, this threshold is set to . During the replanning, the M* planner considers the current locations of the previously arrived robots as their source locations and excludes the robots which already have reached their respective goal locations. For prioritized planning, the robots that arrive later are considered to have a lower priority than the robots arrived already, and compute their path considering the previous robots’ positions as dynamic obstacles. Figure 8 shows the results of the experiments for two different workspace sizes: and .
6.6 Payments under Sparcas
SPARCAS is different from the other collision avoiding mechanisms in its use of payments which ensure truthful participation of the competitive robots. Therefore, it is a natural question to find out how large the payments are in comparison with the valuations received by the robots. In our experiment with a workspace size of , 95.12% of the robots were never needed to pay. For the number of robots: and , the tuple of average valuation and average payment of the robots were , , , , , and respectively. Similarly, another important question is whether the robots encounter a negative payoff, i.e., payment more than valuation. In the experiment, we find that the answer to this is negative. Hence the robots have incentives to voluntarily participate in this mechanism. We also find, quite expectedly as was argued in Footnote 5, that the payments by the robots are always nonnegative.
7 Discussions
We presented a scalable decentralized collision avoidance mechanism for a competitive multirobot system using ideas of mechanism design. We prove that it is truthful, efficient, deadlockfree, and budgetbalanced. We exhibit experimentally that it is scalable to hundreds of robots, and can handle dynamic arrival without compromising the pathlength optimality too much. In future, we would like to extend the algorithm to multiintersection ‘trafficjam’s and conduct experiments on a real multirobot system.
References

Amir et al. [2015]
Ofra Amir, Guni Sharon, and Roni Stern.
Multiagent pathfinding as a combinatorial auction.
In
TwentyNinth AAAI Conference on Artificial Intelligence
, 2015.  Azarm and Schmidt [1997] K. Azarm and G Schmidt. Conflictfree motion of multiple mobile robots based on decentralized motion planning and negotiation. In IEEE international conference on robotics and automation, volume 4, pages 3526–3533, 1997.
 Bererton et al. [2004] Curt Bererton, Geoffrey J Gordon, and Sebastian Thrun. Auction mechanism design for multirobot coordination. In Advances in Neural Information Processing Systems, pages 879–886, 2004.
 Bogue [2016] R. Bogue. Growth in ecommerce boosts innovation in the warehouse robot market. Industrial Robot: An International Journal, 43(6):583–587, 2016.
 Börgers [2015] Tilman Börgers. An introduction to the theory of mechanism design. Oxford University Press, USA, 2015.
 Calliess et al. [2011] JanP Calliess, Daniel Lyons, and Uwe D Hanebeck. Lazy auctions for multirobot collision avoidance and motion control under uncertainty. In International Conference on Autonomous Agents and Multiagent Systems, pages 295–312. Springer, 2011.

Chen et al. [2017]
Yu Fan Chen, Miao Liu, Michael Everett, and Jonathan P How.
Decentralized noncommunicating multiagent collision avoidance with deep reinforcement learning.
In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pages 285–292. IEEE, 2017.  Chun et al. [1999] L. Chun, Z. Zheng, and W Chang. A decentralized approach to the conflictfree motion planning for multiple mobile robots. In IEEE international conference on robotics and automation (ICRA), volume 2, pages 1544–1549, 1999.
 Clarke [1971] E. H. Clarke. Multipart pricing of public goods. Public Choice, 11:17–33, 1971.
 Desai et al. [2017] Ankush Desai, Indranil Saha, Jianqiao Yang, Shaz Qadeer, and Sanjit A. Seshia. DRONA: a framework for safe distributed mobile robotics. In Proceedings of the 8th International Conference on CyberPhysical Systems, ICCPS 2017, Pittsburgh, Pennsylvania, USA, April 1820, 2017, pages 239–248, 2017.
 Desaraju and How [2012] V.R. Desaraju and J. P. How. Decentralized path planning for multiagent teams with complex constraints. Autonomous Robots, 32(4):385–403, 2012.
 Dhinakaran et al. [2017] Aparna Dhinakaran, Mo Chen, Glen Chou, Jennifer C Shih, and Claire J Tomlin. A hybrid framework for multivehicle collision avoidance. In 2017 IEEE 56th Annual Conference on Decision and Control (CDC), pages 2979–2984. IEEE, 2017.
 Erdmann and LozanoPerez [1986] M. Erdmann and T. LozanoPerez. On multiple moving objects. In ICRA, volume 3, pages 1419–1424, 1986.
 Garage [2011] Willow Garage. Turtlebot. Website: http://turtlebot.com/, 2011.
 Gibbard [1973] A. Gibbard. Manipulation of voting schemes. Econometrica, 41:587–602, 1973.
 Groves [1973] T. Groves. Incentives in teams. Econometrica, 41:617–631, 1973.
 Guizzo [2008] E. Guizzo. Three engineers, hundreds of robots, one warehouse. IEEE Spectrum, 45(7):26–34, 2008.

Hart et al. [1968]
P. Hart, N. Nilsson, and B. Raphael.
A formal basis for the heuristic determination of minimum cost paths.
IEEE Trans. Syst. Sci. Cybern., 4(2):100–107, 1968.  Hoffmann and Tomlin [2008] G. Hoffmann and C. Tomlin. Decentralized cooperative collision avoidance for acceleration constrained vehicles. In IEEE conference on decision and control (CDC), pages 4357–4363, 2008.
 Jager and Nebel [2001] M. Jager and B. Nebel. Decentralized collision avoidance, deadlock detection, and deadlock resolution for multiple mobile robots. In IEEE/RSJ international conference on intelligent robots and systems (IROS), volume 3, pages 1213–1219, 2001.
 Lagoudakis et al. [2005] Michail G Lagoudakis, Evangelos Markakis, David Kempe, Pinar Keskinocak, Anton J Kleywegt, Sven Koenig, Craig A Tovey, Adam Meyerson, and Sonal Jain. Auctionbased multirobot routing. In Robotics: Science and Systems, volume 5, pages 343–350. Rome, Italy, 2005.
 Nunes and Gini [2015] Ernesto Nunes and Maria Gini. Multirobot auctions for allocation of tasks with temporal constraints. In TwentyNinth AAAI Conference on Artificial Intelligence, 2015.
 OlfatiSaber et al. [2007] R. OlfatiSaber, J. Fax, and R. Murray. Consensus and cooperation in networked multiagent systems. Proceedings of the IEEE, 95(1):215–233, 2007.
 Pallottino et al. [2004] L. Pallottino, V. Scordio, and A Bicchi. Decentralized cooperative conflict resolution among multiple autonomous mobile agents. In IEEE conference on decision and control (CDC), volume 5, pages 4758–4763, 2004.
 Purwin et al. [2008] O. Purwin, R. D’Andrea, and J Lee. Theory and implementation of path planning by negotiation for decentralized agents. Robotics and Autonomous Systems, 56(5):422–436, 2008.
 Quigley et al. [2009] M. Quigley, B. Gerkey, K. Conley, J. Faust, T. Foote, J. Leibs, E. Berger, R. Wheeler, and A. Y. Ng. ROS: an opensource robot operating system. In OpenSource Software workshop of the International Conference on Robotics and Automation (ICRA), 2009.
 Roberts [1979] Kevin Roberts. The Characterization of Implementable Choice Rules, chapter Aggregation and Revelation of Preferences, pages 321–348. North Holland Publishing, 1979.
 Saha et al. [2014] Indranil Saha, Rattanachai Ramaithitima, Vijay Kumar, George J. Pappas, and Sanjit A. Seshia. Automated composition of motion primitives for multirobot systems from safe LTL specifications. In 2014 IEEE/RSJ International Conference on Intelligent Robots and Systems, Chicago, IL, USA, September 1418, 2014, pages 1525–1532, 2014.
 Saha et al. [2016] Indranil Saha, Rattanachai Ramaithitima, Vijay Kumar, George J. Pappas, and Sanjit A. Seshia. Implan: Scalable incremental motion planning for multirobot systems. In 7th ACM/IEEE International Conference on CyberPhysical Systems, ICCPS 2016, Vienna, Austria, April 1114, 2016, pages 43:1–43:10, 2016.
 Satterthwaite [1975] M. Satterthwaite. Strategyproofness and Arrow’s conditions: Existence and correspondence theorems for voting procedures and social welfare functions. Journal of Economic Theory, 10:187–217, 1975.
 Shoham and LeytonBrown [2008] Y. Shoham and K. LeytonBrown. Multiagent Systems: Algorithmic, GameTheoretic, and Logical Foundations. Cambridge University Press, 2008.
 Snape et al. [2010] Jamie Snape, Jur Van Den Berg, Stephen J Guy, and Dinesh Manocha. Smooth and collisionfree navigation for multiple robots under differentialdrive constraints. In Intelligent Robots and Systems (IROS), 2010 IEEE/RSJ International Conference on, pages 4584–4589. IEEE, 2010.
 Takei et al. [2012] Ryo Takei, Haomiao Huang, Jerry Ding, and Claire J Tomlin. Timeoptimal multistage motion planning with guaranteed collision avoidance via an openloop game formulation. In 2012 IEEE International Conference on Robotics and Automation, pages 323–329. IEEE, 2012.
 Turpin et al. [2014] Matthew Turpin, Nathan Michael, and Vijay Kumar. Capt: Concurrent assignment and planning of trajectories for multiple robots. International Journal of Robotic Research, 33(1), 2014.
 van den Berg and Overmars [2005] J. van den Berg and M. Overmars. Prioritized motion planning for multiple robots. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 2217–2222, 2005.
 Velagapudi et al. [2010] P. Velagapudi, K. Sycara, and P. Scerri. Decentralized prioritized planning in large multirobot teams. In IEEE/RSJ international conference on intelligent robots and systems (IROS), pages 4603–4609, 2010.
 Vickrey [1961] W. Vickrey. Counter speculation, auctions, and competitive sealed tenders. Journal of Finance, 16(1):8–37, 1961.
 Wagner and Choset [2011] Glenn Wagner and Howie Choset. M: A complete multirobot path planning algorithm with performance bounds. In IROS, pages 3260–3267, 2011.
 Wagner and Choset [2015] Glenn Wagner and Howie Choset. Subdimensional expansion for multirobot path planning. Artificial Intelligence, 219:1 – 24, 2015.
 [40] M. Wulfraat. Is Kiva systems a good fit for your distribution center? an unbiased distribution consultant evaluation. http://www.mwpvl.com/html/kiva_systems.html. Accessed: October 2016.
 Yu and LaValle [2013] Jingjin Yu and Steven M. LaValle. Planning optimal paths for multiple robots on graphs. In ICRA, pages 3612–3617, 2013.
Comments
There are no comments yet.