Integer Programming for Multi-Robot Planning: A Column Generation Approach

06/08/2020 ∙ by Naveed Haghani, et al. ∙ 12

We consider the problem of coordinating a fleet of robots in a warehouse so as to maximize the reward achieved within a time limit while respecting problem and robot specific constraints. We formulate the problem as a weighted set packing problem where elements are defined as being the space-time positions a robot can occupy and the items that can be picked up and delivered. We enforce that robots do not collide, that each item is delivered at most once, and that the number of robots active at any time does not exceed the total number available. Since the set of robot routes is not enumerable, we attack optimization using column generation where pricing is a resource-constrained shortest-path problem.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In this paper, we tackle multi-robot planning (MRP), which aims to route a fleet of robots in a warehouse so as to achieve the maximum reward in a limited amount of time, while not having the robots collide and obeying the constraints of individual robots. In MRP, individual robots may make multiple trips over a given time window and may carry multiple items on each trip. We optimize the efficiency of the warehouse, not the makespan, since we expect new orders to be continuously added. Our contributions are that (1) we adapt the integer linear programming (ILP) formulation and column generation (CG) approach for (prize collecting) vehicle routing

(Desrochers et al. 1992, Stenger et al. 2013) to MRP and (2) adapt the seminal work of (Boland et al. 2017) to permit efficient optimization by avoiding consideration of every time increment.

Routing problems for a fleet of robots in a warehouse are often treated as Multi-Agent Pathfinding problems (MAPF) (Stern et al. 2019). In MAPF, we are provided with a set of agents, each with an initial position and destination. The goal is to minimize the sum of the travel times from the initial position to the destination over all agents such that no collisions occur. MAPF can be formulated as a minimum cost multi-commodity flow problem on a space-time graph (Yu and LaValle 2013)

. Optimization can be tackled using multiple heuristic and exact approaches, including search

(Li et al. 2020a), linear programming (Yu and LaValle 2013), branch-cut-and-price (Lam et al. 2019), satisfiability modulo theories (Surynek 2019), and constraint programming (Gange et al. 2019).

One common shortcoming in MAPF approaches is that they require that robot assignments be set before a robot route can be solved. The delegation of robot assignments and the optimal set of routes for the fleet are treated as independent problems. Several recent works (Ma et al. 2017, Liu et al. 2019, Grenouilleau et al. 2019, Farinelli et al. 2020) solve this combined problem in a hierarchical framework, i.e., assigning tasks first by ignoring the non-colliding requirement and then planning collision-free paths based on the assigned tasks. However, these methods are non-optimal as the consideration of possible collisions can easily affect the optimal task assignment for the fleet.

We organize this paper as follows. In Section 2, we formulate the MRP as an ILP, which we attack using CG in Section 3. In Section 4, we solve the corresponding pricing problem as a resource-constrained shortest-path problem (RCSP). In Section B, we provide dual optimal inequalities, which accelerate CG. In Section 5, we demonstrate the effectiveness of our approach empirically. In Section 6, we conclude and discuss extensions.

2 Problem Formulation

In this section we present the problem we call Multi-Robot Planning, outlining it and then formulating it as an ILP. We conclude with detailing feasibility constraints and cost associations for robot routes. We are given a fleet of mobile warehouse robots that enter the warehouse floor from a single location, called the launcher, pick up one or multiple items inside the warehouse, and deliver them to the launcher before the time limit. Each item has a reward (i.e., negative cost) and a time window during which the item can be picked up. Each robot has a capacity and is allowed to perform multiple trips. At the initial time, the fleet of robots is located at the launcher, however we also allow for some robots, called extant robots, to begin at other locations. The use of extant robots permits re-optimization as the environment changes, e.g. when items have their rewards changed or when items are added or removed. Our goal is to plan collision-free paths for the robots to pick up and deliver items and minimize the overall cost.

For computational efficiency, we approximate the continuous space-time positions that robots occupy by treating the warehouse as a 4-neighbor grid and treating time as a set of discrete time points. Each position on the grid is referred to as a cell. Most cells are traversable for the robot but some cells are labeled as obstacles and cannot be traversed, we call these obstructed. Through each time period, robots are capable remaining stationary or moving to an adjacent unobstructed cell in the four main compass directions, which we connect through edges. Robots are required to avoid collisions by not occupying the same cell at any time point and not traversing the same edge in opposite directions between any successive time points. Every item is located at a unique cell. Robots incur a cost while deployed on the grid and for moving on the grid, however they can obtain a reward for servicing an item. To service an item, a robot must travel to the specific cell where the item is located during the item’s associated serviceable time window. Servicing an item consumes a portion of the robots capacity, which can be refreshed once it travels back to the launcher.

We formulate MRP as an ILP problem using the following notation. We use to denote the set of feasible robot routes, which we index by . We note that is too large to be enumerated. We use to denote the cost of robot route . We use to describe a solution where is in the solution IFF . We describe the sets of items, times, and extant robots as , , and , respectively, which we index by , , and , respectively. We use to denote the time-extended graph. Every represents a space-time position, which is a pair of a location (i.e., an unobstructed cell on the warehouse grid) and a time . Two space-time positions are connected by a (directed) space-time edge IFF the locations of and are the same cell or adjacent cells and the time of is the time of plus one.

We describe routes using for . We set IFF route services item . We set IFF route is active (meaning moving or waiting) at time . We set IFF route includes space-time position . We set IFF route is associated with extant robot . We set IFF route uses space-time edge . This edge is associated with adjacent cells and in space and time . Thus, indicates that a robot on route crosses from at time to at time OR from at time to at time . We use to denote the total number of robots available in the fleet. We write MRP as an ILP as follows, followed by an explanation of the objective and constraints.

1:repeat
2:      Solve the RMP over
3:     
4:     
5:until 
6: Solve ILP in (1)-(6) over instead of
7:Return
Algorithm 1 Optimization via Column Generation
(1)
(2)
(3)
(4)
(5)
(6)

In (1), we minimize the cost (that is, maximize the reward) of the MRP solution. In (2), we enforce that no item is serviced more than once. In (3), we enforce that no more than the available number of robots is used at any given time. In (4), we enforce that each extant robot is associated with exactly one route. In (5), we enforce that no more than one robot can occupy a given space-time position. In (6), we enforce that no more than one robot can move along any space-time edge.

We describe a set of feasibility constraints and cost terms for robot routes in our application. (1) Each item can only be picked up during its time window . (2) Each item uses units of capacity of a robot. The capacity of a robot is . An active robot is associated with an initial space-time position (at the initial time, i.e., time 1) and a remaining capacity .

The cost associated with a robot route is defined by the following terms. (1) is the cost associated with servicing item . (2) are the costs of being on the floor and moving respectively, which depreciate the robot. Using , , and , we write as follows.

3 Column Generation for MRP

Since in practice cannot be enumerated, we attack optimization in (1)-(6) using column generation (CG). Specifically, we relax to be non-negative and construct a sufficient set to solve optimization over using CG. CG iterates between solving the LP relaxation of (1)-(6) over , which is referred to as the Restricted Master Problem (RMP), followed by adding elements to that have negative reduced cost, which is referred to as pricing. Below we formulate pricing as an optimization problem using , , , , and to refer to the dual variables over constraints (2)-(6) of the RMP respectively.

(7)

We terminate optimization when the solution to (7) is non-negative, which means that is provably sufficient to exactly solve the LP relaxation of optimization over  (Lübbecke and Desrosiers 2005). We initialize with any feasible solution (perhaps greedily constructed) so as to ensure that each is associated with a route. At termination of CG, if , then the solution, i.e. the tracks defined by , is provably optimal. Otherwise, an approximate solution can be produced by solving the ILP formulation over or the formulation can be tightened using valid inequalities, such as subset row inequalities (Jepsen et al. 2008). We can also use branch-and-price (Barnhart et al. 1996) to formulate CG inside a branch-and-bound formulation. Algorithm 1 shows pseudocode for CG. We show an enhanced version of CG motivated by dual optimal inequalities (DOI) that we propose in Appendix B

4 Solving the Pricing Problem

In this section, we consider the problem of pricing, which we show is a resource-constrained shortest-path problem (RCSP) (Righini and Salani 2008). We organize this section as follows. In Section 4.1, we formulate pricing as an RCSP over a graph whose nodes correspond to space-time positions and whose resources correspond to the items picked up. In Section 4.2, we accelerate computation from Section 4.1 by coarsening the graph, leaving only locations of significance such as item locations across time. In Section 4.3, we further accelerate computation by limiting the times considered while still achieving exact optimization during pricing. In Section 4.4, we show that CG can be accelerated by updating the for all more often than the remainder of the dual solution, saving computation time by precluding the need to reconstruct the coarsened graph as often between rounds of pricing.

4.1 Basic Pricing

In this section we establish a weighted graph admitting an injunction from the routes in to the paths in the graph. For a given route , the sum of the weights along the corresponding path in the weighted graph is equal to the route’s reduced cost . Thus finding the lowest-cost feasible path in this graph solves Eq (7). The graph proposed is a modified form of the time-extended graph . Nodes are added to represent start/end locations, item pickups, and the use of an extant robot. Weights are amended by the corresponding dual variables associated with a given node/edge. We solve a RCSP over this graph where the resources are the items to be pick up.

Formally, consider a graph with paths described by for , where indicates that edge is traversed by the path on the graph corresponding to route . Each edge has an associated weight . There is a node in for each , for each pairing of and denoted , for each denoted , the source node , and the sink node . We ensure that for all . For each pair of space-time positions occurring at the same cell at times (representing a wait action), we set . We set IFF robot route transfers from to and no pickup is made at .

For each pair of space-time positions occurring at times and and associated with space-time edge (representing a move action), we set . We set IFF robot route transfers from to and no pickup is made at . For each , which occurs at space-time position , we set . We set IFF robot route picks up item at time . For each , which occurs at an associated , we provide identical outgoing terms for as we do (except there is no self connection to ). We set IFF robot route transfers from the position of item to and item is picked up at time on route . For each we connect the to the launcher at time denoted with weight . We set IFF the robot route appears first at . For each we set . We set IFF the robot route appears first at . For each , has one single outgoing connection to with weight .

For each we set . We set IFF the robot route has its last position at . Using defined above we express the solution to (7) as an ILP ( followed by description) using decision variables where is equal to for all .

(8)
(9)
(10)
(11)

In (8) we provide objective s.t. for all . In (9) we ensure that describes a path from to across space time. In (10) we ensure that capacity is obeyed. In (11) we ensure that each item is picked up at most once. Optimization in (8)-(11) is strongly NP-hard as complexity grows exponentially with (Desrochers et al. 1992).

4.2 Efficient Pricing: Considering Only Nodes Corresponding to Items

In this section we rewrite the optimization for pricing in a manner that vastly decreases graph size allowing optimization to be efficiently achieved for the RCSP solver. We exploit the fact that given the space-time positions where item pickups occur, we can solve of the remainder of the problem as independent parts. Each such independent part is solved as a shortest path problem, which can be solved via a shortest path algorithm such as Dijkstra’s algorithm (Dijkstra and others 1959).

We now consider a graph with node set with edge set , decision and weights . There is one node in for each excluding those for , i.e., . For any , IFF there exists a path from to in traversing only intermediate nodes that exist in . We set to be the weight of the shortest path from to in using only intermediate nodes in . This is easily computed using a shortest path algorithm. We set IFF is followed by in robot route when ignoring nodes in . Replacing with respectively in (8)-(11) we have a smaller but equivalent optimization problem permitting more efficient optimization.

4.3 More Efficient Pricing: Avoiding Explicit Consideration of All Times

The optimization in Eq (8)-(11) over requires the enumeration of all , which is expensive. In this section we circumvent the enumeration of all pairs by aggregating time into sets in such a manner so as to ensure exact optimization during pricing. For every , we construct , which is an ordered subset of the times where includes initially and and is augmented as needed. We order these in time where is the ’th value ordered from earliest to latest. defines a partition of the window into sets, where the ’th set is defined by

We use to define the graph and solution mapping. Here consists of and one node for each . We define if route services item at a time in as its first pick up. The remaining terms are defined similarly over aggregated time sets. We assign each to be some minimum over the possible paths in associated with . We set for all . We set . We set . For any pair of unique and windows we set . Evaluating each of the terms amounts to solving a basic shortest path problem (no resource constraints), meaning not all terms mentioned in these optimizations need be explicitly computed. Replacing with in (8)-(11) we have a smaller optimization problem permitting more efficient optimization, which provides a lower bound on (8)-(11).

Optimization produces a feasible route when each item in the route is associated with exactly one unique time. In pursuit of a feasible route, we add the times associated with items in the route to their respective sets. We iterate between solving the RCSP over and augmenting the until we obtain a feasible route. This must ultimately occur since eventually would include all for all . Though it should occur much earlier in practice. We provide pseudocode for this pricing method in Algorithm 2 in Appendix A.

4.4 Partial Optimization of the Restricted Master Problem for Faster pricing

Solving the pricing problem is the key bottleneck in computation experimentally. One key time consumer in pricing is the computation of the terms, which can easily be avoided by observing that terms are offset by changes in and but the actual route does not change so long as , , and are fixed. We resolve the RMP fully only periodically so that we can perform several round of pricing using different terms leaving the fixed.

5 Experiments

We run two sets of experiments to empirically study our model. In the first set, we test our model on two classes of random, synthetic problem instances, recording relevant performance and solution statistics. We take a close look at the distribution of these results. Next we compare our algorithm to a modified version employing MAPF to assess the added value of the algorithm’s consideration of robot collisions in the formulation.

5.1 Algorithm Performance

We study the performance of our algorithm on two distinct problem classes where each class includes a set of 100 random instances with specific, shared parameters. Each class shares the same grid size, number of time steps, number of serviceable items, number of map obstacles, and number of robots. Given a set of problem parameters, a single instance additionally includes a random set of obstacle locations, item locations and their respective demands and time windows, and extant robot start locations. We solve each instance over the class, recording the LP objective solution and solving the corresponding ILP over the column set obtained through CG. For each class of problems, to establish the algorithm’s performance and the quality of its solutions, we look at the distribution of the times and numbers of iterations required for CG to converge, the LP objective of the CG solution, and the corresponding relative gaps. The relative gap is defined as the the absolute difference between our integer solution (the upper bound) and the lower bound (the LP objective solution) divided by the lower bound. We normalize so as to efficiently compare the gap obtained (upper bound - lower bound) across varying problem instances. Experiments are run in MATLAB and CPLEX is used as our general purpose MIP solver.

We solve the RCSP in pricing using an exponential time dynamic program outlined in Appendix C. In each round of pricing we return the twenty lowest reduced cost columns we obtain, if they all have negative reduced cost. Otherwise, we return as many negative reduced cost columns as we obtain. We update , , , and the associated graph components every three CG iterations, unless we are unable to find a negative reduced cost column in a given iteration, in which case update all dual variables and rerun pricing. If at any point pricing fails to find a negative reduced cost column while all dual variables are up to date, then we have finished optimization and we conclude CG. To ensure feasibility for the initial round of CG, we initialize the RMP with a prohibitively high cost dummy route for each , where all but . These dummy routes represent and active robot route and thus guarantee that Eq 4 is satisfied. They ensure feasibility, but are not active at termination of CG due to their prohibitively high cost.

In our first class of problems we use a 10x10 grid, 4 total robots with 2 initially active, 15 serviceable items, and 30 total time steps. Each robot, including the extant ones, has a capacity of 6, while each item has a random capacity consumption uniformly distributed over the set {1,2,3}. We set both

and to 1, and the reward for servicing any item, , is -50. Each item’s time window is randomly set uniformly over the available times and can be up to 20 time periods wide. Each map has 15 random locations chosen to serve as obstacles that are not traversable. We solve 100 unique random instances and aggregate the results in Table 1. A sample problem with the solution routes is shown in Figure 1. Each plot in the Figure 1 shows a snapshot in time of the same instance’s solution. A snapshot shows each robot’s route from the initial time up to the time of the snapshot.

Time (sec) Iterations LP Objective Integral Objective Relative Gap
mean 236.3 24.7 -581.0 -574.6 .01
median 160.0 24 -586.2 -581 .01
Table 1: 10x10 grid results over 100 random problem instances
Figure 1: Robot route results for a single instance over 3 snapshots in time. Each track is a robot route up through that time step. Traversable cells, obstacles, the starting/ending launcher, item locations, and extant robot locations are all noted in the legend. (Left): t = 8 snapshot (Middle): t = 16 snapshot (Right): t = 30 (end time) snapshot

We see that over the problem instances in this class we have an average run time of 160 seconds requiring on average 24.7 CG iterations. We report an average LP objective of -581.0 and an average relative gap of .01, thus certifying that we are efficiently producing near optimal solutions. In 93 out of the 100 instances the approximate solution to Eq (1)-(6) reused robots after they returned to the launcher.

In our second class of problems we use a 20x20 grid, 5 total robots with 2 initially active, 25 serviceable items, and 100 total time steps. Each robot, including the extant ones, has a capacity of 6 while each item has a random capacity consumption uniformly distributed over the set {1,2,3}. We set both and to 1 and the reward for servicing any item, , is -50. Each item’s time window is randomly set uniformly over the available times and can be up to 8 time periods wide. Each map has 40 random locations chosen to serve as obstacles that are not traversable. We run on 100 unique random instances and aggregate the results in Table 2.

Time (sec) Iterations LP Objective Integral Objective Relative Gap
mean 478.8 30.1 -639.4 -6329.5 .02
median 389.6 30.0 -643.5 -632 .01
Table 2: 20x20 grid results over 100 random problem instances

We see in this class of instances we get an average run time of 478.8 seconds and an average of 30.1 iterations of CG. We get an average LP objective of -639.4 and a relativity gap of .01, again showing that we are efficiently producing near optimal solutions. In all 100 instances the approximate solution to Eq (1)-(6) reused robots after they returned to the launcher.

We see a slight increase in the iterations required for the second problem class with respect to the first problem class. We see a larger growth in the time required for convergence. We expect this trend can be alleviated with the application of heuristic pricing (Danna and Le Pape 2005, Lokhande et al. 2020). Heuristic pricing attacks the pricing optimization problem through the use of heuristic methods. Since we need only produce a negative reduced cost route through each round of pricing, not necessarily the minimum one, heuristic pricing can hasten CG by saving computational time. Such a heuristic would produce approximate solutions with respect to the ordering of the items but still be optimal given a particular ordering. We also see a very small increase in the relative gap on larger problem instances. Though most problems on the 20x20 grid still have a very small gap, we start to see more problems with a gap close to 5%. The relative gap can be reduced by tightening the relaxation through the use of subset row inequalities (Jepsen et al. 2008, Wang and Fowlkes 2017).

5.2 Comparison with MAPF

We compare our algorithm to a modified version that incorporates MAPF. This version will initially ignore robot collision constraints but ultimately consider them after a set of serviceable items are assigned to specific robots. The modified algorithm works as follows. We solve a given problem instance using our CG algorithm, but we neglect the collision constraints, meaning . This closely resembles a vehicle routing problem (Desrochers et al. 1992) and delivers us a set of robot routes, including the items serviced by each robot, however this could include collisions. We then take the disjoint set of items serviced and feed them to a MAPF solver (Li et al. 2020b). The MAPF solver delivers a set of non-colliding robot routes, each attempting to service the set of items assigned to it. If the MAPF solver fails to provide a valid route for a particular robot (i.e., it cannot make it back to the launcher in time) that route is neglected in the algorithm’s final solution.

We compare the resulting objective values from our full CG approach to this modified approach. For the purposes of this comparison, we neglect time constraints for the items so as to be generous to the MAPF solver, which is not equipped to handle time windows for items. We solve 30 random instances with the same parameters. We use a 20x20 grid, 35 serviceable items, 100 random obstacles, 9 total robots, 1 extant robot, and 25 total time steps. We set to 1, to 0, and the reward for servicing any item, , to -15. The objective value results for both approaches are show in table 3. A side by side plot of the objective values are shown in Figure 2.

CG modified CG + MAPF Difference (CG - MAPF)
mean -124.6 -116.8 -7.9
median -122.0 -111.0 -1.0
Table 3: Objective value results for both algorithms over 30 random instances. Our full approach is labeled CG. We compare against modified CG + MAPF.
Figure 2: Objective values for both approaches over each problem instance. Our full CG approach is shown in blue. It is compared against the modified column CG + MAPF approach shown in orange.

We see an average objective difference of -7.9 and a median difference of -1.0 from the modified algorithm to our full algorithm. We note from looking at Figure 2 that many instances deliver very similar objective results, however some show drastic improvements for our algorithm. These instances largely include robot routes that the MAPF algorithm was unable to find a complete route for within the time constraint given the potential collisions with other robots. With such problems we see it is critical to employ our full algorithm that jointly considers routing and assignment.

6 Conclusions

In this paper, we unified the work on multi-agent path finding with the vehicle routing/column generation literature to produce a novel approach applicable to broad classes of multi-robot planning (MRP) problems. Our work treats MRP as a weighted set packing problem where sets correspond to valid robot routes and elements correspond to space-time positions. Pricing is treated as a resource-constrained shortest-path problem (RCSP), which is NP-hard but solvable in practice (Irnich and Desaulniers 2005). We solve the RCSP by adapting the approach of (Boland et al. 2017) to limit the time windows that need be explored during pricing.

In future work, we seek to tighten the LP relaxation using subset row inequalities (Jepsen et al. 2008) and ensure integrality with branch-and-price (Barnhart et al. 1996). Subset row inequalities are trivially applied to sets over the pickup items since they do not alter the solution paths. Similarly, branch-and-price would be applied following the vehicle routing literature to sets over pickup items (Desrochers et al. 1992). As well, we intend to incorporate heuristic pricing to solve the resource-constrained shortest-path problem in pricing more efficiently, thus increasing the scalability of the algorithm. We also seek to provide insight into the structure of dual optimal solutions and study the effect of smoothing in the dual, based on the ideas of (Haghani et al. 2001, 2020). Simply put, we suspect that dual values should change smoothly across space and time, thus we will encourage such solutions over the course of column generation.

References

  • C. Barnhart, E. L. Johnson, G. L. Nemhauser, M. W. P. Savelsbergh, and P. H. Vance (1996) Branch-and-price: column generation for solving huge integer programs. Operations Research 46, pp. 316–329. Cited by: §3, §6.
  • N. Boland, M. Hewitt, L. Marshall, and M. Savelsbergh (2017) The continuous-time service network design problem. Operations Research 65 (5), pp. 1303–1321. Cited by: §1, §6.
  • E. Danna and C. Le Pape (2005) Branch-and-price heuristics: a case study on the vehicle routing problem with time windows. In Column generation, pp. 99–129. Cited by: §5.1.
  • M. Desrochers, J. Desrosiers, and M. Solomon (1992) A new optimization algorithm for the vehicle routing problem with time windows. Operations Research 40 (2), pp. 342–354. Cited by: §1, §4.1, §5.2, §6.
  • E. W. Dijkstra et al. (1959) A note on two problems in connexion with graphs. Numerische Mathematik 1 (1), pp. 269–271. Cited by: §4.2.
  • A. Farinelli, A. Contini, and D. Zorzi (2020) Decentralized task assignment for multi-item pickup and delivery in logistic scenarios. In Proceedings of the 19th International Joint Conference on Autonomous Agents and Multi-Agent Systems (AAMAS), pp. 1843–1845. Cited by: §1.
  • G. Gange, D. Harabor, and P. J. Stuckey (2019) Lazy CBS: implicit conflict-based search using lazy clause generation. In Proceedings of the 29th International Conference on Automated Planning and Scheduling (ICAPS), pp. 155–162. Cited by: §1.
  • F. Grenouilleau, W. van Hoeve, and J. N. Hooker (2019) A multi-label A* algorithm for multi-agent pathfinding. In Proceedings of the 29th International Conference on Automated Planning and Scheduling (ICAPS), pp. 181–185. Cited by: §1.
  • N. Haghani, C. Contardo, and J. Yarkony (2001) Smooth and flexible dual optimal inequalities. arXiv preprint arXiv:2001.02267. Cited by: §6.
  • N. Haghani, C. Contardo, and J. Yarkony (2020) Relaxed dual optimal inequalities for relaxed columns: with application to vehicle routing. arXiv preprint arXiv:2004.05499. Cited by: §6.
  • S. Irnich and G. Desaulniers (2005) Shortest path problems with resource constraints. In Column generation, G. Desaulniers, J. Desrosiers, and M. M. Solomon (Eds.), pp. 33–65. Cited by: §6.
  • M. Jepsen, B. Petersen, S. Spoorendonk, and D. Pisinger (2008) Subset-row inequalities applied to the vehicle-routing problem with time windows. Operations Research 56 (2), pp. 497–511. Cited by: §3, §5.1, §6.
  • E. Lam, P. Le Bodic, D. Harabor, and P. J. Stuckey (2019) Branch-and-cut-and-price for multi-agent pathfinding. In

    Proceedings of the 28th International Joint Conference on Artificial Intelligence (IJCAI)

    ,
    pp. 1289–1296. Cited by: §1.
  • J. Li, G. Gange, D. Harabor, P. J. Stuckey, H. Ma, and S. Koenig (2020a) New techniques for pairwise symmetry breaking in multi-agent path finding. In Proceedings of the 30th International Conference on Automated Planning and Scheduling (ICAPS), Cited by: §1.
  • J. Li, A. Tinka, S. Kiesel, J. W. Durham, T. K. S. Kumar, and S. Koenig (2020b) Lifelong multi-agent path finding in large-scale warehouses. In Proceedings of the 19th International Joint Conference on Autonomous Agents and Multi-Agent Systems (AAMAS), pp. 1898–1900. Cited by: §5.2.
  • M. Liu, H. Ma, J. Li, and S. Koenig (2019) Task and path planning for multi-agent pickup and delivery. In Proceedings of the 18th International Joint Conference on Autonomous Agents and Multi-Agent Systems (AAMAS), pp. 1152–1160. Cited by: §1.
  • V. S. Lokhande, S. Wang, M. Singh, and J. Yarkony (2020) Accelerating column generation via flexible dual optimal inequalities with application to entity resolution. New York, New York. Cited by: §5.1.
  • M. E. Lübbecke and J. Desrosiers (2005) Selected topics in column generation. Operations Research 53 (6), pp. 1007–1023. Cited by: §3.
  • H. Ma, J. Li, T. K. S. Kumar, and S. Koenig (2017) Lifelong multi-agent path finding for online pickup and delivery tasks. In Proceedings of the 16th International Conference on Autonomous Agents and Multi-Agent Systems (AAMAS), pp. 837–845. Cited by: §1.
  • G. Righini and M. Salani (2008) New dynamic programming algorithms for the resource constrained elementary shortest path problem. Networks: An International Journal 51 (3), pp. 155–170. Cited by: §4.
  • A. Stenger, M. Schneider, and D. Goeke (2013) The prize-collecting vehicle routing problem with single and multiple depots and non-linear cost. EURO Journal on Transportation and Logistics 2 (1-2), pp. 57–87. Cited by: §1.
  • R. Stern, N. R. Sturtevant, A. Felner, S. Koenig, H. Ma, T. T. Walker, J. Li, D. Atzmon, L. Cohen, T. K. S. Kumar, R. Barták, and E. Boyarski (2019) Multi-agent pathfinding: definitions, variants, and benchmarks. In Proceedings of the 12th International Symposium on Combinatorial Search (SoCS), pp. 151–159. Cited by: §1.
  • P. Surynek (2019) Unifying search-based and compilation-based approaches to multi-agent path finding through satisfiability modulo theories. In Proceedings of the 28th International Joint Conference on Artificial Intelligence (IJCAI), pp. 1177–1183. Cited by: §1.
  • S. Wang and C. C. Fowlkes (2017) Learning optimal parameters for multi-target tracking with contextual interactions.

    International journal of computer vision

    122 (3), pp. 484–501.
    Cited by: §5.1.
  • J. Yu and S. M. LaValle (2013) Planning optimal paths for multiple robots on graphs. In Proceedings of the IEEE International Conference on Robotics and Automation (ICRA), pp. 3612–3617. Cited by: §1.

Appendix A More Efficient Pricing Algorithm

In this section, we provide pseudocode for the pricing method described in Section 4.3 as an algorithm. We use and to denote the minimizers used to calculate . The term is the time component minimizer for while is the time component minimizer for . These are the outgoing and incoming times, respectively, for the shortest path on between and . We use tot_sz to keep track of the total number of elements in all sets. A growth in tot_sz implies a potential mismatch between the incoming time and the outgoing time at an item location. In such cases, tot_sz grows to narrow the time ranges for the sets, making it less likely to have a mismatch. When tot_sz does not grow, no mismatch is possible and the solution obtained is guaranteed to represent a feasible route, therefore we terminate pricing. Algorithm 2 shows pseudocode for the pricing method described in Section 4.3.

repeat
     tot_size
      Solve Eq (8)-(11) over
     for ( s.t.  do
         if  and for any  then
              Let correspond to item
              
         end if
         if  and for any  then
              Let correspond to item
              
         end if
     end for
until  tot_size=
Let correspond to the solution to (8) computed via optimization over
Return
Algorithm 2 Fast Pricing

Appendix B Dual Optimal Inequalities

In this section we provide dual optimal inequalities (DOI) for MRP, which accelerate CG and motivates better approximate solutions at termination of CG when the LP relaxation is loose. Our DOI are motivated by the following observation. No optimal solution to (7) services an item that is associated with a net penalty instead of a net reward for being serviced, meaning that must be observed. This is because simply not servicing the item but using an identical route in space time would produce a lower reduced cost route. Since the dual LP relaxation of (1)-(6) is increasing with respect to no optimal dual solution to (1)-(6) will violate the following . By enforcing at each iteration of CG optimization we accelerate CG by restricting the dual space that need be explored. In the primal form, Eq (1) and Eq (2) are altered as follows with primal variables corresponding to .

In our experiments we only use the replacements above when solving the ILP over the column set . When enforcing that is binary, the technique described often leads to a closer approximations to the solution to Eq (1)-(6). We map any solution derived this way to one solving the original ILP by arbitrarily removing over-included items from routes in the outputted solution until each item is included no more than once.

Appendix C Resource-Constrained Shortest-Path Solver

We solve the resource-constrained shortest-path problem (RCSP) in pricing via an exponential time dynamic program that iterates over the possible remaining capacity levels for a robot (starting at the highest), enumerating all available routes corresponding to paths in at each capacity level, and then progressing to the down to the next highest remaining capacity level. At each level we eliminate any inferior routes. We call a route inferior to another if all of the following are satisfied: (1) it has the same remaining capacity and corresponding position in the node set as the other, (2) it has lower cumulative edge cost on than the other, and (3) it has a set of serviceable items available to it that is a subset of the other’s.

We start at the maximum robot capacity and enumerate all possible, single visit traversals. We save a robot state for each such route. A robot state is defined by its current corresponding position in the node set , the items serviced, the cost incurred so far on , and the remaining capacity. We set to be the cost of a path at graph position with path history , a set of all previously visited graph positions. We set to be the remaining capacity available for a robot at corresponding graph position with history . For a robot route with initial visit at item at corresponding graph position we have the following remaining capacity and cost.

(12)
(13)

We then move on to the next highest remaining robot capacity level. For each saved robot state at this remaining capacity, we enumerate all available single visit traversals (including back to the launcher) and save a state for each route generated. An item is available to be visited if that item has not yet been visited in the route and visiting it would not exceed the remaining capacity. For a robot traveling from corresponding graph position with history , to corresponding graph position , we have the following update for the cost and remaining capacity.

(14)
(15)

We eliminate all inferior routes generated and continue on to the next capacity level until we have exhausted all possible remaining capacity levels. At the end we have series of routes drawn out, including the route with minimum cost on . We can return any number of these that have a negative cost. Returning more serves to reduce the number of CG iterations, but comes with a trade-off of burdening the RMP with more, possibly unnecessary, columns. Ultimately, we choose to return the twenty lowest reduced cost routes found.