[Paper Review] Bidirectional Temporal Plan Graph: Enabling Switchable Passing Orders for More Efficient Multi-Agent Path Finding Plan Execution

Yifan Su, Rishi Veerapaneni+1 more|arXiv (Cornell University)|Dec 30, 2023

Robotic Path Planning Algorithms4 citations

TL;DR

This paper introduces the Bidirectional Temporal Plan Graph (BTPG), a new graphical representation that enables dynamic switching of agent passing orders at shared locations during multi-agent path finding execution. By allowing 'first-come-first-served' passing when delays occur, BTPG reduces unnecessary waiting by 8–20% compared to traditional Temporal Plan Graphs (TPGs), with two anytime algorithms—BTPG-naïve and BTPG-optimized—enabling efficient construction of collision-free and deadlock-free plans under execution uncertainty.

ABSTRACT

The Multi-Agent Path Finding (MAPF) problem involves planning collision-free paths for multiple agents in a shared environment. The majority of MAPF solvers rely on the assumption that an agent can arrive at a specific location at a specific timestep. However, real-world execution uncertainties can cause agents to deviate from this assumption, leading to collisions and deadlocks. Prior research solves this problem by having agents follow a Temporal Plan Graph (TPG), enforcing a consistent passing order at every location as defined in the MAPF plan. However, we show that TPGs are overly strict because, in some circumstances, satisfying the passing order requires agents to wait unnecessarily, leading to longer execution time. To overcome this issue, we introduce a new graphical representation called a Bidirectional Temporal Plan Graph (BTPG), which allows switching passing orders during execution to avoid unnecessary waiting time. We design two anytime algorithms for constructing a BTPG: BTPG-naïve and BTPG-optimized. Experimental results show that following BTPGs consistently outperforms following TPGs, reducing unnecessary waits by 8-20%.

Motivation & Objective

• To address the inefficiency of traditional Temporal Plan Graphs (TPGs) in multi-agent path finding, where fixed passing orders cause unnecessary waits due to execution delays.
• To enable dynamic switching of passing orders at shared locations during execution, improving plan robustness and reducing total execution time.
• To develop a new graphical representation—Bidirectional Temporal Plan Graph (BTPG)—that captures switchable dependencies while ensuring collision-free and deadlock-free execution.
• To design anytime algorithms (BTPG-naïve and BTPG-optimized) for constructing BTPGs efficiently under time constraints.
• To empirically validate that BTPG-based execution outperforms TPG-based execution in terms of reduced waiting time and improved execution efficiency under realistic delay conditions.

Proposed method

• Proposes the Bidirectional Temporal Plan Graph (BTPG) as an extension of the Temporal Plan Graph (TPG), allowing bidirectional edges to represent switchable passing orders at shared locations.
• Introduces the concept of 'bidirectional pairs'—pairs of type-2 edges in the TPG that can be reversed during execution to reduce waiting time.
• Designs two anytime algorithms: BTPG-naïve performs a depth-first search over singleton type-2 edges to identify potential bidirectional pairs, while BTPG-optimized uses a more efficient DFS with pruning to explore more pairs within a time budget.
• Defines sufficient conditions under which a BTPG remains provably collision-free and deadlock-free even when passing orders are switched during execution.
• Uses the MAPF-DP model to simulate execution uncertainty, where agents may be delayed with a 30% chance at each non-delayed timestep, and evaluates performance under this realistic setting.
• Employs a simulation framework with 10 random seeds per instance across 3,900 simulations to compare BTPG and TPG execution performance on various maps and agent counts.

((a)) Scenario 1.

Experimental results

Research questions

• RQ1 Under what conditions can switching the passing order of agents at shared locations reduce unnecessary waiting without causing collisions or deadlocks?
• RQ2 How can a graphical representation be designed to capture switchable dependencies in a MAPF plan while preserving safety guarantees?
• RQ3 To what extent can anytime algorithms construct BTPGs that enable dynamic passing order switching to improve execution efficiency under agent delays?
• RQ4 How does the performance of BTPG-based execution compare to TPG-based execution in terms of total execution time and waiting time reduction?
• RQ5 What is the trade-off between algorithmic runtime and the number of discovered bidirectional pairs in BTPG construction?

Key findings

• BTPG-based execution consistently outperforms TPG-based execution, reducing unnecessary waiting time by 8–20% across all tested maps and agent counts.
• The improvement of BTPG over TPG is non-negative in all 3,900 simulations, with 41.9% of instances showing 10–20% improvement and 31.2% showing over 20% improvement.
• BTPG-optimized outperforms BTPG-naïve in both the number of bidirectional pairs discovered and the resulting execution time improvement, especially under time constraints.
• Only about 10% of bidirectional pairs are used during execution, but these used pairs are responsible for the majority of the performance gain, indicating high efficiency per pair.
• The BTPG-optimized algorithm achieves better anytime performance than BTPG-naïve, finding more bidirectional pairs within the same time budget due to more effective DFS pruning.
• The runtime of BTPG-optimized is higher than BTPG-naïve, but this is due to exploring more pairs rather than inefficiency, and the additional cost is justified by the performance gains.

((b)) Scenario 2.