Temporal Plan Graph (TPG) Overview

• Temporal Plan Graph is a formal, time-independent graph representation that encodes minimal inter-agent precedence constraints to ensure collision-free and deadlock-free execution amid stochastic delays.
• Extensions such as Bidirectional TPGs (BTPG) and Switchable TPGs (STPG) introduce flexible, dynamic conflict resolution, reducing waiting times and overall execution makespan.
• Optimized algorithms like BTPG-max and IGSES demonstrate significant performance gains and scalability, underpinning robust coordination in domains like warehouse robotics and autonomous vehicle fleets.

A Temporal Plan Graph (TPG) is a formal, time-independent graphical representation used in multi-agent path finding (MAPF) to encode only the minimal inter-agent precedence constraints necessary to guarantee collision-free, deadlock-free execution under real-world execution uncertainties, such as stochastic delays. TPGs, along with their generalizations (Bidirectional TPGs, Switchable TPGs), have become foundational in the design of robust, efficient multi-agent coordination protocols for practical settings where strict synchronization to discrete timesteps is infeasible. This article surveys the precise formalism, construction, extensions, optimization algorithms, and recent empirical findings for the TPG abstraction.

1. Formal Structure and Semantics of Temporal Plan Graphs

A Temporal Plan Graph is a directed acyclic graph $G = (V, E)$ partitioned as $E = E_1 \cup E_2$, where

• $$V = \{v_i^m \mid m \in \{1, \dots, M\},\, i = 0, \dots, |P^m|\}$$, with $v_i^m$ denoting the $i$th state (vertex) along agent $m$’s path $P^m$;
• $$E_1 = \{(v_i^m, v_{i+1}^m) \mid \forall m,\, i < |P^m|\}$$ are intra-agent edges enforcing that $v_{i+1}^m$ may be entered only after $v_i^m$;
• $$E_2 = \{(v_i^m, v_j^n) \mid n \neq m,\, \mathrm{loc}(v_i^m) = \mathrm{loc}(v_{j-1}^n),\, t_i^m < t_{j-1}^n\}$$ are inter-agent edges encoding conflict-based precedence constraints between agents at shared spatial locations, with $t^m_i$ the time at which agent $m$ occupies $v^m_i$ in the nominal MAPF solution.

In execution, an agent may only advance along its path when all predecessor edges (from $E_1 \cup E_2$) into its pending state have been “satisfied”—that is, when all required prior agents’ occupancies have occurred. The absence of cycles in $(V, E)$, excluding allowable rotation cycles, ensures this policy is both deadlock- and collision-free regardless of agent delays (Su et al., 6 Aug 2025, Su et al., 2023, Jiang et al., 20 Dec 2024).

2. Construction from MAPF Plans and Space-Order Generalization

To construct a TPG from a space-time MAPF solution, one creates a sequence of vertices $v^m_i$ per agent path $P^m = (\ell_0^m, \ell_1^m, ..., \ell_{T_m}^m)$, adds Type-1 “path” edges $(v_i^m, v_{i+1}^m)$, and for every inter-agent spatial coincidence with temporal precedence ($\ell^m_i = \ell^n_{j-1},\, t^m_i < t^n_{j-1}$), adds Type-2 edges as above.

Recent work proposes an alternative “space-order” perspective, redefining each vertex as a tuple $(s, r)$, where $r$ is the order in which an agent visits location $s$ (not a timestep), leading to a vertex set $V = \bigcup_{j, \tau} (s_j^\tau, r_j^\tau)$. Edges carry precedence over these visitation orders, with rigorous validity criteria: uniqueness, proper start and goal ranks, consistency of order along shared edges (no overtake violations), acyclicity, and the absence of rank “holes” (Wu et al., 23 Apr 2024).

This redefinition enables direct planning in the “space-order” domain, as in Space-Order CBS, which minimizes coordination requirements (inter-agent dependencies) during planning instead of as a post-processing step.

3. Bidirectional and Switchable Extensions: BTPG and STPG

Classical TPGs enforce a fixed agent ordering at each conflict location, which can impose unnecessary waiting when delays invert arrival order. Bidirectional TPGs (BTPGs) and Switchable TPGs (STPGs) relax this rigidity via “switchable” or “bi-pair” edges:

• Bidirectional Pairs (BTPG): Given a conflict at location $\ell$, the directed edge enforcing “agent $m$ before $n$” is replaced by a bidirectional pair $\{(v_i^m, v_j^n), (v_{j+1}^n, v_{i-1}^m)\}$, permitting “first-come-first-served” (FCFS) execution; the policy dynamically discards the losing edge upon execution (Su et al., 6 Aug 2025, Su et al., 2023).
• Switchable Edges (STPG): A subset $S$ of Type-2 edges is designated “switchable” and can be fixed in either direction (orality) before execution, so long as the final precedence graph remains acyclic. STPG optimization algorithms select which conflicts to make switchable to minimize execution makespan, subject to deadlock/collision avoidance (Jiang et al., 20 Dec 2024).

The safety of these relaxations is ensured by cycle-based validity characterizations. In BTPG, only “reachable deadlock cycles” (as defined by agent execution policy) are forbidden, while “non-deadlock cycles” arising from potential but impossible executions are allowed.

4. Algorithms for TPG, BTPG, and STPG Construction and Optimization

Algorithms for constructing and optimizing Temporal Plan Graphs and their generalizations include:

• Naïve BTPG construction: Each Type-2 edge is tentatively paired with its reverse; cycles are checked to ensure deadlock-freedom. Edges whose reversal induces a (legitimate) deadlock cycle cannot be bidirectional (Su et al., 2023).
• Optimized (BTPG-o) and Maximal (BTPG-max) Algorithms: BTPG-o iteratively refines the set of bidirectional pairs by considering non-deadlock cycles per Theorem 3, improving efficiency. BTPG-max further achieves local maximality: once completed, no further safe bi-pair can be added without an actual potential deadlock. BTPG-max proceeds by grouping related Type-2 edges, tentatively adding pairs, and employing a specialized DeadlockCycleDetection procedure to screen for cycles, all within an anytime framework (Su et al., 6 Aug 2025).
• Space-Order CBS: Operates in the space-order domain to resolve conflicts via a constraint tree, with re-planning guided by metrics trading off path length and coordination. The search is weakly complete and minimizes required agent-to-agent precedence (Wu et al., 23 Apr 2024).
• Graph-Based Switchable Edge Search (GSES / IGSES): GSES performs branch-and-bound search over partial switchable edge settlements in STPGs, guided by edge slack-based admissible heuristics. Improved GSES incorporates stronger heuristics (future cost estimation via minimum vertex cover), edge grouping, prioritized branching by criticality (slack), and incremental update of longest path computations, yielding dramatic speedups (up to $35\times$) and high success rates (85–92% for 60–200 agents) (Jiang et al., 20 Dec 2024).
• Mixed-Integer Linear Programming (MILP): Models the edge selection and arrival times, but faces poor scaling.

Anytime properties are prevalent in BTPG and IGSES, allowing early interruption and yielding feasible (if suboptimal) relaxations.

5. Empirical Evaluation and Performance Analysis

Empirical findings across benchmarks—den520, warehouse, Paris, random, empty, Berlin maps—demonstrate substantial gains for BTPG and STPG methods over classical TPGs:

Method	Bi-pairs (Paris, $K=150$)	Mean Execution-Time Improvement (over TPG)
BTPG-o	$1\,679$	up to 18%
BTPG-max	$6\,649$	up to 40% via grouping
SO-CBS $w=0.5$	—	5–15% (up to 20% reduced wait time)
IGSES (STPG)	—	up to $35\times$ search time speedup

• BTPG-max typically finds $2\times$–$6\times$ more bidirectional pairs than BTPG-o, with practical build-times (tens of seconds). Anytime performance plateaus early, and grouping amplifies benefits (Su et al., 6 Aug 2025).
• Execution times decrease by up to 40% in BTPG-max (w/ grouping), compared to $8$–$20\%$ gains for previous BTPG algorithms (Su et al., 2023).
• Space-Order CBS reduces coordination edges by $30$–$90\%$ and unique agent communications by $10$–$50\%$ versus traditional post-processing, with execution wait-time reductions of up to $20\%$ (Wu et al., 23 Apr 2024).
• IGSES achieves $12\times$–$35\times$ speedup over GSES for STPG optimization, and solves up to $92\%$ of $200$-agent instances within $16$ seconds, a $2\times$ improvement in solvability (Jiang et al., 20 Dec 2024).

A consistent finding is that further relaxations (bi-pairs, switchable edges, direct space-order search) yield greater robustness to delays and lower average makespan. Gains compound with more sophisticated preprocessing (grouping, incremental updates, prioritized search).

6. Practical Implications, Application Domains, and Limitations

TPG frameworks and their relaxations underpin robust execution policies for MAPF in domains such as warehouse robotics, autonomous vehicle fleets, and multi-drone coordination, particularly in settings with communication delays or execution noise. Augmenting a standard MAPF plan with a BTPG or STPG layer substantially reduces unnecessary waiting without altering the core planner.

These methods guarantee collision- and deadlock-freedom even under adversarial, unpredictable delays—no online replanning or model of delay processes is required (Su et al., 2023, Su et al., 6 Aug 2025).

However, trade-offs exist between preprocessing time (TPG/BTPG/STPG construction), execution flexibility, and plan optimality. For very large agent populations, exact optimal STPG construction (e.g., MILP) is infeasible, but algorithmic advances (IGSES) address scalability. Space-Order CBS increases the underlying search space, but empirical results indicate planning times remain practical (typically under 1 minute for $K \leq 100$ (Wu et al., 23 Apr 2024)). The theoretical guarantees (cycle conditions, local maximality) do not preclude efficiency loss if grouping or anytime interruption is misapplied.

7. Connections, Open Problems, and Ongoing Work

Current research explores further generalizations, including switchable ordering for groups larger than pairs, dynamic adaptation to unexpected high-impact delays, and integration with learning-based MAPF solvers. The interplay between plan flexibility (more bi-pairs, switchable edges) and plan cost reduction (makespan, coordination) remains an open optimization frontier.

A plausible implication is that extending the space-order paradigm to multi-stage planning (with incremental feedback) could yield even greater delay robustness, especially in domains with dynamic obstacles or heterogeneous agent capabilities. The formal analysis of cycle admissibility criteria for more complex conflict patterns is ongoing.

The TPG abstraction and its variants have catalyzed a shift in the MAPF literature from space-time rigid assignment toward flexible, order-centric, execution-robust coordination frameworks (Jiang et al., 20 Dec 2024, Su et al., 6 Aug 2025, Wu et al., 23 Apr 2024, Su et al., 2023).