Simple Temporal Network (STN) Overview

• Simple Temporal Network (STN) is a directed acyclic model that captures essential temporal constraints to guarantee collision- and deadlock-free multi-agent execution.
• It decouples agent progression from strict timing, allowing transitions as soon as prerequisite actions complete, which reduces waiting times during delays.
• Advanced techniques like bidirectional and switchable constraints optimize the STN framework, significantly enhancing scalability and execution efficiency in complex deployments.

A Temporal Plan Graph (TPG) is a directed acyclic graph representation that encodes the precedence relations among agents in a Multi-Agent Path Finding (MAPF) solution, capturing only those temporal ordering constraints necessary to guarantee both collision-free and deadlock-free execution. Unlike classic space-time plans—which are brittle to real-world execution delays—TPGs allow agents to progress as soon as required predecessors have completed, without reference to explicit global timetables or timestamps. This model has led to a broad spectrum of generalizations and optimization techniques, including bidirectional TPGs (BTPG/BTPG-max) and switchable TPGs (STPG), with demonstrated robustness and scalability in large multi-agent pathfinding deployments.

1. Formal Definitions and Construction

A Temporal Plan Graph is constructed from a MAPF solution as follows. For $M$ agents, let $P^m = (\ell_0^m, \ell_1^m, \dots, \ell_{T_m}^m)$ denote the path for agent $m$, where each $\ell_i^m$ is a location on the roadmap. The TPG is $G = (V, E)$ with edge set $E = E_1 \cup E_2$:

• $$V = \{ v_i^m \mid m \in \{1, \dots, M\}, i \in \{0, \dots, |P^m|\} \}$$, where $v_i^m$ represents agent $m$ at the $i$th step of its path.
• Type-1 (intra-agent) edges: $E_1 = \{ (v_i^m, v_{i+1}^m) \mid i < |P^m| \}$ enforce path order for each agent.
• Type-2 (inter-agent) edges: $$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 \}$$ impose collision-avoidance dependencies when two agents occupy the same location.

A TPG is valid if and only if it is acyclic; deadlock or collision can only occur if a directed cycle (excluding rotation cycles under some execution policies) is present (Su et al., 6 Aug 2025, Su et al., 2023, Jiang et al., 20 Dec 2024).

2. Execution Policy, Robustness, and Coordination

The fundamental execution policy for TPGs is: an agent may transition from $v_i^m$ to $v_{i+1}^m$ as soon as all predecessors of $v_i^m$ in $E$ have been satisfied—regardless of actual elapsed time. This model:

• Decouples (as much as is feasible) progress from precise timing, directly addressing real-world timing variance and stochastic delays.
• Guarantees collision and deadlock freedom so long as the TPG remains acyclic (Su et al., 6 Aug 2025).

Importantly, this time-independence exposes a key trade-off: the number and arrangement of Type-2 edges determine the degree of required inter-agent coordination. Reducing unnecessary Type-2 edges or replacing them with switchable constraints (see below) yields greater execution flexibility and lower expected makespan under delays (Wu et al., 23 Apr 2024).

3. Bidirectional and Switchable Temporal Plan Graphs

A Bidirectional TPG (BTPG) generalizes the TPG by allowing certain conflict dependencies to be switchable at execution time. Instead of encoding a strict passing order at a conflict (e.g., agent $m$ before $n$), a bidirectional pair allows either order, to be decided dynamically based on actual arrival:

• A bidirectional pair consists of two opposing Type-2 edges, e.g., $\{(v_i^m, v_j^n), (v_{j+1}^n, v_{i-1}^m)\}$, corresponding to $(m \prec n) \vee (n \prec m)$ at a given location.
• During execution, the agent who arrives first proceeds, with the chosen direction instantiated and the other discarded. This implements a distributed, first-come-first-served protocol at potential conflict points (Su et al., 6 Aug 2025, Su et al., 2023).

Empirically, BTPGs reduce unnecessary agent waiting: BTPG-max finds up to $\sim$6,600 bi-pairs on large grids (vs. 1,000 for BTPG-o; e.g., Paris map). This translates to up to 40% mean execution-time improvement over classic TPGs (den520, Paris, Berlin), with consistent deadlock- and collision-freedom (Su et al., 6 Aug 2025, Su et al., 2023).

Switchable Temporal Plan Graphs (STPG) further extend BTPG to the general setting where each Type-2 edge can either be "fixed" (unidirectional) or "switchable" (direction chosen at execution) (Jiang et al., 20 Dec 2024).

4. Optimization Algorithms for TPGs, BTPGs, and STPGs

A major research focus is the automated construction and optimization of TPG-derived structures for improved execution robustness:

• BTPG-max algorithm: Iteratively replaces as many Type-2 edges as possible with bi-pairs, testing each candidate for the existence of reachable deadlock cycles. It achieves local maximality: no further bi-pairs can be added without inducing an actual deadlock risk. The algorithm's core is a reachability-based deadlock cycle detection subroutine with complexity $O((|V|+|E|)^2|E_2|^2)$ worst-case, but practical runtimes are tens of seconds on large instances due to early convergence and optional grouping (Su et al., 6 Aug 2025).
• BTPG-naïve and BTPG-optimized: Simpler anytime procedures that check cycles under less sophisticated criteria; BTPG-o generally finds about twice the bi-pairs of BTPG-n in the same time for warehouse-scale problems (Su et al., 2023).
• Space-Order CBS: A framework for constructing TPGs directly that minimizes coordination by searching over visitation orders (using relative space-rank rather than time). This reduces the number of Type-2 edges by 30–90% relative to standard postprocessing approaches, lowering both agent-agent communication and makespan under delays (Wu et al., 23 Apr 2024).
• STPG Optimization via GSES/IGSES: Graph-Based Switchable Edge Search (GSES) and its improved variant (IGSES) use best-first search over fix/switch decisions, with IGSES leveraging tighter admissible heuristics, prioritized branching, grouping of switchable edges, and incremental longest-path updates for orders-of-magnitude speedup. IGSES achieves 85–92% success rates on large MAPF instances (up from 40–50% for GSES) with $12\times$–$35\times$ lower runtime (Jiang et al., 20 Dec 2024). An MILP encoding is also available but does not scale to larger systems.

Algorithm	Execution Principle	Improvement vs. Baseline
BTPG-max	Max. safe bi-pairs, DFS cycles	Up to 40% execution time gain
BTPG-o	Iterative, non-maximal cycles	8–21% execution time gain
IGSES	Heuristic-optimized GSES	$12$–$35\times$ runtime speedup
Space-Order CBS	Direct planning in space-order	30–90% fewer coordination edges

5. Empirical Findings and Scalability

Benchmarks across den520, warehouse, Paris, random, empty, and Berlin maps with 50–150 agents under realistic delay models (10% delay probability, $5$-step delay with $0.3$ probability) demonstrate robust improvements:

• BTPG-max consistently yields higher numbers of bi-pairs and lower mean execution time relative to both TPG and BTPG-o (Su et al., 6 Aug 2025).
• In "Paris_1_256" with 150 agents and aggressive grouping, BTPG-max achieves rapid anytime improvement, converging to a higher total of switchable conflicts than prior algorithms.
• Under random $5\%$ agent delays of $+100$ steps, Space-Order CBS reduces total wait time by up to $20\%$ and overall makespan by $5$–$15\%$ compared to postprocessed ECBS-POST TPGs (Wu et al., 23 Apr 2024).
• IGSES solves 85–92% of large maps within a $16$s budget with drastically lower search node expansions than baseline GSES (Jiang et al., 20 Dec 2024).

All approaches maintain practical build times (tens of seconds for BTPG-max; $<1$ minute for Space-Order CBS and IGSES with agents $K \leq 100$) and afford anytime behavior, allowing the user to trade preprocessing effort for execution flexibility.

6. Theoretical Properties and Guarantees

• Acyclicity is necessary and sufficient for safe TPG or BTPG execution. All algorithms employ cycle checks to maintain this invariant.
• Deadlock-Freedom: Theorems in (Su et al., 6 Aug 2025, Su et al., 2023, Jiang et al., 20 Dec 2024) prove that the presence of non-deadlock cycles (in BTPG/BTPG-o/max) or proper settlement of switchable edges (in IGSES) cannot induce reachable execution deadlocks.
• Local Maximality: BTPG-max is locally optimal; adding any further bi-pair would violate safety (Su et al., 6 Aug 2025).
• Completeness: Space-Order CBS is weakly complete; given sufficient time, it finds a valid TPG if any exists (Wu et al., 23 Apr 2024).
• Objective Functions: Both path-length and various coordination metrics (total and unique coordination) can be explicitly traded off in TPG construction (Wu et al., 23 Apr 2024).

7. Applications, Limitations, and Outlook

TPGs and their generalizations (BTPG, STPG, Space-Order TPG) are widely applicable in warehouse robotics, automated vehicle coordination, and any multi-agent setting where real-world execution deviates from nominal plans due to stochastic delays. They enable delay-robust, communication-efficient, and scalable execution policies, often requiring only lightweight local commitment protocols without online replanning.

Current limitations remain in the computational costs of full optimal STPG construction in very large or tightly coupled instances (MILP methods do not scale), though heuristic and grouping-based algorithms have closed much of this gap (Jiang et al., 20 Dec 2024). Open research issues include tighter integration of communication network constraints, continuous-space generalization, and deeper theoretical analysis of the limits of switchable acyclicity under more complex real-world timing models.

In summary, the Temporal Plan Graph and its extensions provide a rigorously justified, practically validated substrate for robust multi-agent path execution, with ongoing advances in both theory and scalable combinatorial optimization.