{'fraction_non_alphanumeric': 0.03150620754275006, 'fraction_numerical': 0.008432888264230498, 'mean_word_length': 4.431933842239186, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Path Planning with Kinematic Constraints for Robot Groups

Path planning for multiple robots is well studied in the AI and robotics communities. For a given discretized environment, robots need to find collision-free paths to a set of specified goal locations. Robots can be fully anonymous, non-anonymous, or organized in groups. Although powerful solvers for this abstract problem exist, they make simplifying assumptions by ignoring kinematic constraints, making it difficult to use the resulting plans on actual robots. In this paper, we present a solution which takes kinematic constraints, such as maximum velocities, into account, while guaranteeing a user-specified minimum safety distance between robots. We demonstrate our approach in simulation and on real robots in 2D and 3D environments.


I. INTRODUCTION
Path planning for multiple robots has many applications, including improving traffic at intersections, search and rescue, formation control, warehouse management, airport scheduling, and assembly planning. There are two existing major approaches: The first one works in continuous environments and can take kinematic constraints into account but does not perform well in highly cluttered, puzzle-like scenes, and the second one works in discrete environments with artificial agents without motion constraints.
Hence, it is desirable to combine the two approaches by providing a planner which can deal with highly cluttered, puzzle-like scenes even under kinematic constraints. We tackle this challenge by introducing a postprocessing step that works on the output of a discrete solver. While the solver itself is allowed to make simplifying assumptions in order to run faster, our postprocessing step reinstates the adherence to real-world kinematic constraints.
Solvers from the AI community for Multi-Agent Path-Finding (MAPF) problems and Target-Allocation and Path-Finding (TAPF) problems are able to solve instances with hundreds of agents [1]. For the MAPF problem, each agent has an assigned start-and goal location. The objective is to find a set of synchronized paths, one path per agent, such that each agent reaches its goal location without colliding with other agents while minimizing the number of actions required. Each agent can either move to an adjacent location in one timestep or wait. The TAPF problem is a generalization in which the agents are partitioned into K groups. A set of goal locations is assinged to each group. A solver     allocates a specific goal location to each agent and reports a set of synchronized paths for all agents. If K = 1, all agents are anonymous, and, if K equals the number of agents, TAPF is the same as MAPF. Therefore, we will focus on TAPF in the remainder of this paper. Using a TAPF solution on real robots has several limitations: (a) robots have kinematic constraints, such as maximum velocities and accelerations; and (b) the generated solution's timing is inflexible, necessitating costly replanning when robots execute the solution imperfectly. A framework that does not explicitly address faulty execution can cause undesirable robot-robot collisions or repeated replanning. To overcome these limitations while still being able to make use of powerful solvers developed in the AI community, we propose the use of a postprocessing step based on the algorithmic framework of Simple Temporal Networks (STNs).

II. TAPF
We are given an undirected graph Each robot a i j has a unique start location s i j ∈ V 1 , and the i-th group has a set of unique target locations {g i 1 , g i 2 , . . . , g i Ki }. A solution to the TAPF problem finds K permutations, one for each group, to uniquely assign a target location to each robot and a collision-free path for each robot to navigate from its start location to the assigned goal location. A more rigorous mathematical description is given in [1].
The makespan is the total time until the last robot reached its goal location. A solution is optimal if the makespan is minimal. For the case of a single group, the problem can be solved in polynomial time. However, in general, it is NPhard to approximate an optimal solution within any constant factor less than 4 /3 [2].
The Conflict-Based Min-Cost-Flow (CBM) algorithm uses a hierarchical approach, where the lower level uses a maxflow algorithm and the higher level uses a best-first search, which tries to resolve conflicts as they occur [1]. It has been arXiv:1704.07538v1 [cs.AI] 25 Apr 2017 Fig. 2. Temporal plan graph with safety markers.
shown empirically that this method works well in warehouse domains with dozens of teams and hundreds of agents.
An example of a TAPF instance is shown in Fig. 1. Here, there are two groups, that each contain a single robot. The robots are holonomic and move in a discretized environment. One optimal solution of the given TAPF problem is A, B, C, D, E for one robot and B, C, F, C, D for the other robot.

III. STN
The output of the TAPF solver is a set of synchronized paths, assuming that robots can traverse the unit-length edges in unit time. We call the change of location of an agent event.
In order to include kinematic constraints, such as maximum velocities of the different robots, we use a Temporal Plan Graph (TPG). The TPG captures the partial order of the events determined by the TAPF solver. More formally, the TPG is an acyclic graph G 2 = (V 2 , E 2 ), where each vertex v ∈ V 2 represents an event and each edge u, v ∈ E 2 indicates that u should be scheduled before v.
In the TAPF case, there are two kinds of temporal precedences. First, the precedence which captures the location visit order for each robot individually. Second, the TAPF solution synchronizes the paths between robots to avoid conflicts. This happens if robot 1 visits a location at timestep t 1 and robot 2 visits the same location at timestep t 2 > t 1 .
Moreover, we can add safety markers as additional events to ensure a minimum safety distance between robots at any time. There are several methods to do so. An LP-solver can be used to optimize for maximum throughput or minimum makespan [3]. If the desired safety distance divides the edge length, the problem can be solved with a user-specified edgelength in strongly polynomial time by using a shortest path algorithm [4]. One example of a TPG with safety markers is shown in Fig. 2.
The TPG captures only the necessary partial order on events. In order to include kinematic constraints such as maximum velocities for robots or certain parts of the environment, we can extend it to a simple temporal network (STN). An STN can be encoded as directed graph G 3 = (V 3 , E 3 ), where V 3 = {X 0 , X 1 , . . . , X N } and E 3 are the sets of events and edges, respectively. Each edge e = X i , X j ∈ E 3 has lower and upper bounds [LB(e), U B(e)], indicating that X j has to be scheduled between LB(e) and U B(e) time units after X i .

IV. EXPERIMENTS
We implement TAPF and MAPF solvers as well as various variants of the STN framework in C++. For performance evaluation, we randomly generate 10 × 10 × 5 maps with varying numbers of robots, groups, and obstacles and measure how long the TAPF solver takes to find an optimal solution. For example, a scenario with 150 obstacles and 100 robots in 5 groups can be solved in about 5 s on commodity hardware. The time the STN requires to compute a solution varies by method and desired safety distance. Interestingly, its runtime is smaller in the common case of a large safety distance, because fewer markers are required in that case. In a warehouse-like domain with 100 robots, it takes 4 s to compute a solution.
We verified our approach in simulation using the V-REP robotics simulator for differential drive robots, 6-legged robots, and quadcopters. Furthermore, we performed experiments with up to 8 iRobot Create2 robots, verifying that actual robots are actually able to follow the computed trajectories. An example is shown in Fig. 3.

V. CONCLUSION
We presented an approach for using powerful solvers from the AI community for multi-agent path finding on actual robots, which obey kinematic constraints. Although not shown here, our approach is optimal with respect to the makespan under some conditions. We demonstrate the applicability of our approach through simulation and on actual robots. In the future, we would like to test our framework on physical quadcopters and add an execution monitoring framework which makes use of the "slack" of the STN to avoid costly replanning in case of inaccurate execution.