From Space-Time to Space-Order: Directly Planning a Temporal Planning Graph by Redefining CBS

TL;DR

This paper addresses the gap between theoretical MAPF space-time plans and real-world robotic execution by directly planning a Temporal Plan Graph (TPG) through Space-Order CBS (SO-CBS). SO-CBS reframes the TPG as a set of space-visitation order paths and adapts the CBS framework with vertex, edge, target, and deadlock constraints to produce valid TPGs with minimized coordination. Empirically, SO-CBS achieves substantial reductions in coordination (notably Type-2 edges) and improved robustness to delays, at the cost of longer planning times, across multiple MAPF benchmarks. The work promises improved multi-robot robustness and reduced inter-agent communication in practical deployments, with avenues for further enhancement via post-processing integrations and completeness proofs.

Abstract

The majority of multi-agent path finding (MAPF) methods compute collision-free space-time paths which require agents to be at a specific location at a specific discretized timestep. However, executing these space-time paths directly on robotic systems is infeasible due to real-time execution differences (e.g. delays) which can lead to collisions. To combat this, current methods translate the space-time paths into a temporal plan graph (TPG) that only requires that agents observe the order in which they navigate through locations where their paths cross. However, planning space-time paths and then post-processing them into a TPG does not reduce the required agent-to-agent coordination, which is fixed once the space-time paths are computed. To that end, we propose a novel algorithm Space-Order CBS that can directly plan a TPG and explicitly minimize coordination. Our main theoretical insight is our novel perspective on viewing a TPG as a set of space-visitation order paths where agents visit locations in relative orders (e.g. 1st vs 2nd) as opposed to specific timesteps. We redefine unique conflicts and constraints for adapting CBS for space-order planning. We experimentally validate how Space-Order CBS can return TPGs which significantly reduce coordination, thus subsequently reducing the amount of agent-agent communication and leading to more robustness to delays during execution.

Figures (7)

• Figure 1: TPGs on the random-32-32 map. Each row corresponds to an agent's path with each blue dot being a location on the path. Red arrows are Type-2 TPG edges between different agents, indicating coordination and potential waiting. Our method significantly decreases the number of Type-2 edges in the resultant TPG and is more robust to scenarios with delays. Note "real" TPGs from actual MAPF plans have never been visualized before.
• Figure 2: Given a MAPF problem with two agents (a), existing methods compute non-conflicting space-time paths that require agents to be at a specific location at a specific time (b). (a) shows how space-time paths may require agents to wait (e.g. the blue agent waiting at (4,2)), and have spatial overlaps in their paths (denoted by the purple region). To allow agents to handle delays or move at arbitrary velocities, the output space-time paths can be post-processed into a Temporal Plan Graph which removes waits and defines a precedence order (c). The TPG consists of vertices $s^t_j$ representing agent $j$ at location $s$ at timestep $t$, and edges denoting dependencies. Cross edges (gray) in the TPG from $s^t_j \rightarrow s^{t'}_k$, define possible coordination instances where agent $k$ needs to wait for agent $j$ to traverse location $s$ first. These occur at overlapping regions (e.g. purple in (a)) which require coordination to avoid collisions if we want agents to move independently and not timestep aligned. For example in (c), $(3,2)^2_2 \rightarrow (3,2)^3_1$ means that agent 1 needs to wait for agent 2 to leave $(3,2)$ before it can enter. In this paper, we show that by redefining vertices to space-visitation order $(s,r)$ vertices representing the $r^{th}$ agent to visit location $s$, a TPG in MAPF is equivalent to the agents having a set of non-interesting space-visitation order paths (d). This equivalence allows us to directly plan a TPG.
• Figure 3: Example edge conflict. Agent 1 (blue) and agent 2 (red) need to cross a corridor in the same direction. The top-left subplot shows the paths of two agents. Solid line segments represent the corresponding agent hold order $r=0$ at the location; dashed line segments represent the corresponding agent hold order $r=1$. In the first half of the corridor, agent 2 has a higher order and must follow agent 1. However, the relative order of two agents swap at the edge $(3,4) \rightarrow (4,4)$. We label them as location $A$ and location $B$. The top-right subplot shows the space-order vertices at that particular edge. This edge has an edge conflict as during execution agent 1 wait at location $A$ for agent 2 to visit $B$, but agent 2 would be stuck behind agent 1 before $A$; thus both agents would wait forever. The bottom row shows two edge constraints to resolve this conflict. The dashed edges are forbidden while the solid edges are allowed. If both ends of an arrow are within the shaded area, the corresponding edge is disallowed.
• Figure 4: Example deadlock cycle. The left subplot shows the space-order paths of two agents. All vertices in the paths have default order $0$, except that vertices marked with a colored square represent the corresponding agent has order $1$ at that location. e.g. at $(2,4)$ agent 1 has order $1$ and agent 2 has order $0$. The right subplot shows the corresponding TPG. Colored edges are Type-1 edges. Grey cross-edges are Type-2 edges specifying dependency at overlapping locations. There exists a cycle $((2,4),1) \rightarrow ... \rightarrow ((4,2),0) \rightarrow ((4,2),1) \rightarrow ... \rightarrow ((2,4),0) \rightarrow ((2,4),1)$ which we highlight in orange. The cycle consists of two Type-2 edges and two sequences of Type-1 edges. The cycle implies a deadlock. Agent 1 will stuck waiting to enter $(2,4)$, while agent 2 will stuck waiting to enter $(4,2)$.
• Figure 5: We compare SO-CBS with our total and unique objectives across different $w$ with ECBS-POST. ECBS-POST plans space-time paths using ECBS and then post-processes it into a TPG while our method directly produces a TPG. $w$ trades off minimizing coordination ($\uparrow w$) versus path length ($\downarrow w$). Our methods substantially decrease coordination compared to ECBS-POST (first two columns). The last two columns show SO-CBS is more robust under random delays by comparing wait time and execution time with ECBS-POST.

Theorems & Definitions (27)

• Definition 1: Vertex Criteria
• Definition 2: Start Criteria
• Definition 3: Target Criteria
• Definition 4: Edge Criteria
• Definition 5: Cycle Criteria
• Definition 6: Relative Criteria
• Definition 7: Total Coordination
• Definition 8: Unique Coordination
• Definition 9: Vertex Constraint
• Definition 10: Target Constraint