Discrete-Guided Diffusion for Scalable and Safe Multi-Robot Motion Planning

TL;DR

This paper introduces Discrete-Guided Diffusion, a novel framework that combines discrete MAPF and diffusion models to enable scalable, high-quality multi-robot motion planning in large environments.

Contribution

It presents a new integrated approach that decomposes MRMP into convex subproblems, guiding diffusion models with discrete solutions for improved scalability and trajectory quality.

Findings

Scales to 100 robots in complex environments

Achieves high success rates and planning efficiency

Sets new state-of-the-art performance in large-scale MRMP

Abstract

Multi-Robot Motion Planning (MRMP) involves generating collision-free trajectories for multiple robots operating in a shared continuous workspace. While discrete multi-agent path finding (MAPF) methods are broadly adopted due to their scalability, their coarse discretization severely limits trajectory quality. In contrast, continuous optimization-based planners offer higher-quality paths but suffer from the curse of dimensionality, resulting in poor scalability with respect to the number of robots. This paper tackles the limitations of these two approaches by introducing a novel framework that integrates discrete MAPF solvers with constrained generative diffusion models. The resulting framework, called Discrete-Guided Diffusion (DGD), has three key characteristics: (1) it decomposes the original nonconvex MRMP problem into tractable subproblems with convex configuration spaces, (2) it combines discrete MAPF solutions with constrained optimization techniques to guide diffusion models capture complex spatiotemporal dependencies among robots, and (3) it incorporates a lightweight constraint repair mechanism to ensure trajectory feasibility. The proposed method sets a new state-of-the-art performance in large-scale, complex environments, scaling to 100 robots while achieving planning efficiency and high success rates.

Tables

Table 1. Table 1: Success rate (S, in percentage), running time (T, in seconds), and path length (P).

Map	Robots	DGD			MPD			MMD			SMD
		S	T	P	S	T	P	S	T	P	S	T	P
Basic	6	100	12.2	1.21	76	9.1	1.12	100	27.1	1.12	100	254.3	1.10
	12	96	25.0	1.28	52	8.7	1.10	100	56.0	1.12	N/A	N/A	N/A
	18	96	65.7	1.33	8	9.4	1.09	96	86.3	1.13	N/A	N/A	N/A
Dense	6	100	12.3	1.26	4	9.2	1.11	40	36.5	1.15	100	287.3	1.13
	12	100	32.9	1.35	0	N/A	N/A	8	62.5	1.15	N/A	N/A	N/A
	18	76	47.8	1.37	0	N/A	N/A	8	87.1	1.18	N/A	N/A	N/A
Room	6	100	38.9	1.44	0	N/A	N/A	24	55.5	1.16	100	181.0	1.19
	12	100	84.0	1.50	0	N/A	N/A	4	122.6	1.14	N/A	N/A	N/A
	18	100	219.0	1.55	0	N/A	N/A	0	N/A	N/A	N/A	N/A	N/A
Shelf	6	100	64.6	1.30	0	N/A	N/A	32	48.5	1.18	100	274.3	1.16
	12	100	131.5	1.33	0	N/A	N/A	4	95.1	1.22	N/A	N/A	N/A
	18	84	324.8	1.38	0	N/A	N/A	0	N/A	N/A	N/A	N/A	N/A

Table 2. Table 2: Success rate (S, in percentage) and running time (T, in seconds) across all methods. DM is a standard diffusion model trained on feasible trajectories to directly solve MRMP. The reported running time for DGD is measured under parallel execution.

Map	Robots	DGD		DM		MPD		MMD		SMD
		S	T	S	T	S	T	S	T	S	T
Basic	3	100	6.5	12	4.7	92	9.3	100	13.1	100	76.6
	6	100	12.2	0	N/A	76	9.1	100	27.1	100	254.3
	9	100	17.4	0	N/A	72	9.9	100	41.4	100	504.0
	12	96	25.0	0	N/A	52	8.7	100	56.0	N/A	N/A
	15	96	41.4	0	N/A	12	10.3	100	70.9	N/A	N/A
	18	96	65.7	0	N/A	8	9.4	96	86.3	N/A	N/A
Dense	3	100	6.6	0	N/A	88	8.3	60	19.1	100	81.2
	6	100	12.3	0	N/A	4	9.2	40	36.5	100	287.3
	9	100	18.3	0	N/A	0	N/A	28	51.4	100	582.1
	12	100	32.9	0	N/A	0	N/A	8	62.5	N/A	N/A
	15	96	37.0	0	N/A	0	N/A	4	72.4	N/A	N/A
	18	76	47.8	0	N/A	0	N/A	8	87.1	N/A	N/A
Room	3	100	17.1	4	4.1	12	8.8	60	28.2	100	72.6
	6	100	38.9	0	N/A	0	N/A	24	55.5	100	181.0
	9	100	59.9	0	N/A	0	N/A	8	142.4	96	239.4
	12	100	84.0	0	N/A	0	N/A	4	122.6	N/A	N/A
	15	100	115.5	0	N/A	0	N/A	0	N/A	N/A	N/A
	18	100	219.0	0	N/A	0	N/A	0	N/A	N/A	N/A
Shelf	3	100	31.5	4	4.1	32	9.1	68	23.7	100	88.0
	6	100	64.6	0	N/A	0	N/A	32	48.5	100	274.3
	9	100	80.4	0	N/A	0	N/A	8	61.6	96	607.8
	12	100	131.5	0	N/A	0	N/A	4	95.1	N/A	N/A
	15	92	187.0	0	N/A	0	N/A	0	N/A	N/A	N/A
	18	84	324.8	0	N/A	0	N/A	0	N/A	N/A	N/A

Table 3. Table 3: Path length(P) and acceleration (A) across all methods.

Map	Robots	DGD		DM		MPD		MMD		SMD
		P	A	P	A	P	A	P	A	P	A
Basic	3	1.16	0.008	1.11	0.005	1.11	0.006	1.12	0.006	1.10	0.005
	6	1.21	0.011	N/A	N/A	1.12	0.006	1.12	0.006	1.10	0.006
	9	1.26	0.013	N/A	N/A	1.08	0.008	1.12	0.006	1.12	0.006
	12	1.28	0.014	N/A	N/A	1.10	0.009	1.12	0.006	N/A	N/A
	15	1.31	0.014	N/A	N/A	1.09	0.009	1.12	0.006	N/A	N/A
	18	1.33	0.015	N/A	N/A	1.09	0.008	1.13	0.006	N/A	N/A
Dense	3	1.17	0.007	N/A	N/A	1.14	0.008	1.10	0.006	1.12	0.006
	6	1.26	0.012	N/A	N/A	1.11	0.008	1.15	0.006	1.13	0.007
	9	1.30	0.014	N/A	N/A	N/A	N/A	1.16	0.006	1.13	0.008
	12	1.35	0.016	N/A	N/A	N/A	N/A	1.15	0.006	N/A	N/A
	15	1.35	0.017	N/A	N/A	N/A	N/A	1.17	0.007	N/A	N/A
	18	1.37	0.017	N/A	N/A	N/A	N/A	1.18	0.007	N/A	N/A
Room	3	1.36	0.008	1.12	0.006	1.12	0.007	1.22	0.007	1.17	0.008
	6	1.44	0.013	N/A	N/A	N/A	N/A	1.16	0.007	1.19	0.007
	9	1.49	0.014	N/A	N/A	N/A	N/A	1.15	0.007	1.22	0.008
	12	1.50	0.015	N/A	N/A	N/A	N/A	1.14	0.008	N/A	N/A
	15	1.52	0.016	N/A	N/A	N/A	N/A	N/A	N/A	N/A	N/A
	18	1.55	0.016	N/A	N/A	N/A	N/A	N/A	N/A	N/A	N/A
Shelf	3	1.27	0.008	1.13	0.005	1.15	0.007	1.16	0.006	1.14	0.007
	6	1.30	0.011	N/A	N/A	N/A	N/A	1.18	0.007	1.16	0.008
	9	1.31	0.013	N/A	N/A	N/A	N/A	1.16	0.007	1.17	0.009
	12	1.33	0.013	N/A	N/A	N/A	N/A	1.22	0.008	N/A	N/A
	15	1.36	0.014	N/A	N/A	N/A	N/A	N/A	N/A	N/A	N/A
	18	1.38	0.015	N/A	N/A	N/A	N/A	N/A	N/A	N/A	N/A

Table 4. Table 4: Hyperparameters for Training in Experiments.

HyperParameters	Value
Diffusion Sampling Step	25
Learning Rate	3e-4
Batch Size	64
Optimizer	Adam

Equations

$${\pi }_i^h$$

$$\Vert {\pi }_i^h-{\pi }_j^h{\Vert }_2$$

$$\Vert {\pi }_i^{h+1}-{\pi }_i^h{\Vert }_2$$

$${\mathbf{x}}_t={\mathbf{x}}_{t+1}+\frac{ϵ}{2}{s}_{\theta }({\mathbf{x}}_{t+1},t+1)+\sqrt{ϵ}\cdot z,$$

$${\mathbf{x}}_t={\mathbf{x}}_{t+1}+\frac{ϵ}{2}(s_{\theta }({\mathbf{x}}_{t+1},t+1)+\mathcal{J}({\mathbf{x}}_{t+1},\mathcal{O}))+\sqrt{ϵ}\cdot z,$$

$$\mathcal{J}({\mathbf{x}}_t,\mathcal{O})=\sum _{i=1}^{N_a}{\nabla }_{\mathbf{x}}{d}_o\left({\mathbf{x}}_t^i,\mathcal{O}\right)+\sum _{i=1}^{N_a}{\nabla }_{\mathbf{x}}{d}_a\left({\mathbf{x}}_t^i,{\mathbf{x}}_t^{-i}\right).$$

$$d_o({\mathbf{\pi }}_i,\mathcal{O})$$

$$d_a({\mathbf{\pi }}_i,{\mathbf{\Pi }}_{-i})$$

$${\mathbf{x}}_t={\mathcal{P}}_{{\mathcal{C}}_{\text{f}}^c}\left({\mathbf{x}}_t\right),$$

$${\mathbf{x}}_t={\mathcal{P}}_{\mathbf{\Pi }}\left({\mathbf{x}}_t\right),$$

$${\mathcal{P}}_{\mathbf{\Pi }}(\mathbf{x})=\arg \underset{\mathbf{y}}{\min }\Vert \mathbf{x}-\mathbf{y}{\Vert }_2^2\text{s.t.}\text{Eq. (refeq:robot-avoid), (refeq:dyn)}.$$

$$\mathcal{L}(\mathbf{y},\mathbf{\nu })=$$

$${\mathcal{L}}_{\text{alm}}(\mathbf{y},\mathbf{\nu })=\mathcal{L}(\mathbf{y},\mathbf{\nu })+\rho \Vert {\sum }_{i=1}^{N_a}{\nabla }_{\mathbf{y}}{d}_a\left({\mathbf{y}}_t^i,{\mathbf{y}}_t^{-i}\right){\Vert }^2.$$

$$\displaystyle\bm{x}=\$$

$$\mathbb{E}\left[\text{Error}(\mathcal{U}({\mathcal{P}}_{C_{\text{f}}^c}(\mathbf{x})),C_{\text{f}}^c)\right]\le \xi .$$

Full text

K****eywords Diffusion Models  $\cdot$ Multi-Agent Path Planning  $\cdot$ Multi-Robot Motion Planning

1 Introduction

Multi-Robot Motion Planning (MRMP) is a fundamental problem in robotics that requires generating collision-free trajectories for multiple robots operating in a shared environment. MRMP arises in diverse applications such as automated warehouses, coordinated drone fleets, and autonomous driving. Despite its importance, efficiently solving MRMP in complex environments remains a significant challenge due to the high dimensionality and combinatorial complexity Yu and LaValle (2013).

To address these challenges, two major paradigms have emerged. Optimization-based methods formulate the problem as a continuous, often nonconvex trajectory optimization problem and are capable of producing smooth, high-quality paths Marcucci et al. (2023). However, their scalability is severely limited as the number of robots and obstacles increases. Another body of work considers a discretized version of MRMP, known as Multi-Agent Path Finding (MAPF). It discretizes the space and time, significantly reducing computational complexity Li et al. (2021); Okumura (2024). MAPF algorithms scale to hundreds of robots, but their reliance on discretized grid-based movement and synchronized time steps limits their applicability in continuous and dynamic environments.

To address these limitations, recent work has explored the use of generative models, particularly diffusion models, to learn distributions over trajectories in continuous spaces Xiao et al. (2022); Carvalho et al. (2023). These models show promising results in single-robot planning as they enable diverse and high-quality trajectory generation. However, their extension to multi-robot settings introduces significant challenges: Diffusion models must capture complex inter-robot spatiotemporal dependencies while simultaneously avoiding collisions, a problem that becomes highly intractable as the number of robots and obstacles grows.

Several recent approaches attempt to extend diffusion models to MRMP via gradient-based guidance Shaoul et al. (2024); Ding et al. (2025). These methods are able to generate high quality trajectories, but are limited by two key challenges: First, the difficulty of ensuring the feasibility of the generated trajectories with respect to non-collision and kinodynamic constraints. This is hard since gradient-based guidance cannot natively guarantee global constraint satisfaction. Second, these models struggle in cluttered or dense environments, where the complexity of the configuration space increases. Recently,  Liang et al. (2025) proposed an approach to ensure feasibility through repeated projections within the diffusion process. This is a promising solution, but it comes at a high computational overhead, due to the nonconvexity and high dimensionality of constraints.

Contribution. This paper addresses these challenges through a novel integration of discrete MAPF with continuous denoising diffusion. The proposed Discrete-Guided Diffusion (DGD), first decomposes the original MRMP problem into a sequence of local subproblems with convex configuration space, each defined by the spatiotemporal structure obtained from the MAPF solution. On each subproblem, a diffusion model is then used to generate trajectories guided by this spatiotemporal structure. To ensure feasibility, DGD relies on a lightweight projected guidance rendering each step of the diffusion process feasible, and enforced only when constraint violations are detected. The whole framework is schematically illustrated in Figure 1. The effectiveness and efficiency of DGD is demonstrated both theoretically and practically across a range of challenging benchmarks with up to 100+ robots.

2 Related Work

In this section, we review three research areas that form the foundation for our work: multi-robot motion planning (MRMP), discrete multi-agent path finding (MAPF), and generative models for motion planning. We summarize the key methods and challenges in each area, highlighting the scalability, constraint handling, and feasibility guarantees that motivate our proposed approach.

Multi-robot Motion Planning.

MRMP methods address trajectory generation for multiple robots in continuous space. There are two main approaches for MRMP: (1) Sampling-based algorithm, where constructs feasible trajectories by randomly sampling the state space Gammell et al. (2014); Shome et al. (2020). While sampling-based planners are probabilistically complete, they require dense sampling and struggle to enforce continuous kinodynamic constraints, limiting their practical applications. (2) Optimization-based planner, where the planning problem is formulated as an optimization program, such as a sequential convex program Augugliaro et al. (2012); Park et al. (2020) and a mixed-integer program Mellinger et al. (2012). While optimization-based methods can handle various constraints, extending them to the multi-robot case couples all robots into a single high-dimensional optimization problem, suffering from exponential growth in decision variables and local minima. Recently, Graph of Convex Sets (GCS) has been proposed to mitigate this issue for single robot motion planning by decomposing the environment into a collection of convex regions Marcucci et al. (2023); Chia et al. (2024). However, applying GCS to MRMP is quite challenging due to the spatiotemporal dependencies among multiple robots.

Discrete Multi-agent Path Finding.

Multi-agent path finding (MAPF) focuses on a discretized version of MRMP by discretizing both time and space into steps and grids, respectively Stern et al. (2019). The MAPF literature has produced highly scalable algorithms such as Conflict-Based Search (CBS) and its bounded-suboptimal variants Sharon et al. (2015); Li et al. (2021); Okumura (2024). These planners can coordinate hundreds of agents with correctness and solution quality guarantees in grid worlds by resolving pairwise collisions in a low-dimensional discrete space and have been adopted in large automated-warehouse deployments. However, their reliance on synchronized, axis-aligned motions and fixed timesteps makes it difficult to transfer the resulting plans to real robots with continuous dynamics, kinodynamic limits, or tight clearances; post-processing heuristics such as temporal smoothing or continuous re-planning only partially mitigate this gap Hönig et al. (2018).

Generative models for motion planning.

Diffusion generative models have recently emerged as a powerful alternative to sampling-based and optimization planners, learning a distribution over continuous trajectories that captures multimodality without hand-tuned costs Xiao et al. (2022); Carvalho et al. (2023); Luo et al. (2024). While early work focused on single-robot problems, extending to multi-robot motion planning requires enforcing joint collision and kinodynamic constraints, which dramatically increases the complexity of the diffusion process.

To address this issue, the recent literature has explored three main strategies: (i) Classifier or gradient guidance adds an external collision penalty during the reverse process Ding et al. (2025). Although simple, guidance offers no guarantees on constrained satisfaction and degrades in dense environments. Shaoul et al. (2024) extends this approach by using diffusion models as the single-robot planner in a constraint-based MAPF framework, but this process utilizes diffusion to generate single-robot trajectories without explicitly modeling inter-robot interactions. (ii) Constrained score estimation methods learn the score function with added penalty terms Naderiparizi et al. (2025), but constraints satisfaction still cannot be guaranteed. (iii) Finally, Projection-based refinement methods, Liang et al. (2025), interleaves diffusion steps with a nonlinear projection onto the global feasible set. This approach produces provably collision-free trajectories for a few robots and is therefore central to our discussion and later comparisons. Nonetheless, the need to solve a full high-dimensional projection at every diffusion step incurs substantial computational overhead and limits scalability to larger teams.

To address these limitations, the proposed Discrete-Guided Diffusion (DGD) exploits a hybrid approach where a MAPF-derived spatiotemporal skeleton is fused with a constraint-aware diffusion process inside locally convex subproblems, avoiding Liang et al.’s costly global projections while preserving formal feasibility and yielding state-of-the-art performance on large-scale MRMP benchmarks.

3 Preliminaries

Multi-Robot Motion Planning (MRMP).

MRMP involves computing collision-free trajectories for multiple robots navigating a shared environment from designated start positions to goal states. Let $\mathcal{A}=\{a_{1},\dots,a_{N_{a}}\}$ be a set of $N_{a}$ robots that move in a bounded, planar workspace $\mathcal{W}\subset\mathbb{R}^{2}$ containing a set of static obstacles $\mathcal{O}=\{o_{1},\dots,o_{N_{o}}\}$. The free configuration space is defined as the set of all points in the workspace that are not occupied by obstacles: \mathcal{C}_{\mathrm{f}}:=\mathcal{W}\setminus\bigl{(}\bigcup_{o\in\mathcal{O}}o\bigr{)}.

Each robot $a_{i}$ is modeled as a disk of radius $r_{i}>0$ and is characterized at discrete time steps $h\in\{0,\ldots,H\}$ by a 2-D position $\pi_{i}^{h}=(x_{i}^{h},y_{i}^{h})\in\mathcal{C}_{\mathrm{f}}.$ A trajectory for robot $a_{i}$ is the sequence $\bm{\pi}_{i}:=(\pi_{i}^{0},\pi_{i}^{1},\dots,\pi_{i}^{H}).$ For each robot, their start and target states are defined by sets $\bm{B}=[b_{1},b_{2},\ldots,b_{N_{a}}]$ and $\bm{E}=[e_{1},e_{2},\ldots,e_{N_{a}}]$.

The goal of MRMP is to compute a set of trajectories $\boldsymbol{\Pi}=\{\boldsymbol{\pi}_{1},\boldsymbol{\pi}_{2},\ldots,\boldsymbol{\pi}_{N_{a}}\}$ such that each robot starts at its designated start position and reaches its target position while avoiding collisions with obstacles and other robots. For every time index $h$ we require

[TABLE]

where (1a) enforces obstacle avoidance, (1b) inter-robot separation, and (1c) a first-order kinematic bound with time step $\Delta t$ and speed limit $v_{\max}$.

Multi-Agent Path Finding (MAPF).

In contrast, Multi-Agent Path Finding assumes the configuration space and time to be discretized, which significantly reduces the complexity of the original problem. The workspace is represented by an undirected graph $\mathcal{G}=(V,E)$ whose vertices encode grid cells or roadmap milestones. The input to a MAPF problem is a tuple $\langle\mathcal{G},\mathrm{S},\mathrm{T}\rangle$, where $\mathrm{S}\!:\![1,\ldots,k]\rightarrow V$ maps robots to their source vertices and $\mathrm{T}\!:\![1,\ldots,k]\rightarrow V$ maps robots to their target vertices. At each integer time step $t$, robot $i$ occupies a vertex $v_{i}^{t}\!\in\!V$ and chooses either a wait action or an edge $(v_{i}^{t},v_{i}^{t+1})\in E$.

The result of a MAPF algorithm is a set of discrete multi-robot trajectories $\boldsymbol{\Pi}_{M}=\{\boldsymbol{\pi}_{m,1},\boldsymbol{\pi}_{m,2},\ldots,\boldsymbol{\pi}_{m,N_{a}}\}$, specifying the grid location of each robot at every time step, satisfying vertex conflicts $v_{i}^{t}\neq v_{j}^{t}\ \forall i\neq j,\,t$ and edge conflicts $(v_{i}^{t},v_{i}^{t+1})\neq(v_{j}^{t+1},v_{j}^{t})\ \forall i\neq j,\,t$.

The Discrete-Continuous Gap

The MAPF solution $\boldsymbol{\Pi}_{M}$ satisfies the constraints of the discrete problem, but it does not directly translate to a continuous trajectory for the robots. To obtain a continuous trajectory, three key challenges arise:

Embedding the vertices $V$ of $\mathcal{G}$ in the continuous space $\mathcal{C}_{\mathrm{f}}$, which may not be a grid. 2. 2.

Time-parameterizing each edge into a collision-free segment that respects constraint (1c). This requires ensuring that the trajectory segments do not violate the kinematic limits of the robots. 3. 3.

Although the MAPF solution ensures discrete collision avoidance, it does not exploit constraint (1b) in the continuous space, which can result in suboptimal solutions.

A coarse grid may also lead to unrealistic motions or infeasible timing, whereas a fine grid blows up the state space exponentially, making MAPF itself expensive. To contrast these challenges, this paper proposes a framework that leverages MAPF solely as a structural guide while a continuous diffusion model refines the trajectories to respect (1a)–(1c).

4 Discrete-Guided Diffusion Framework

Solving the MRMP problem poses two fundamental challenges. First, MRMP is NP-hard and the complexity grows exponentially with the number of robots, making it difficult to scale to large problems while preserving high-quality trajectories generation. Second, although generative models offer better scalability and trajectory quality, ensuring the feasibility of entire trajectories remains challenging, particularly in high-dimensional planning spaces.

To address these challenges, this section presents an MRMP framework that couples a discrete MAPF backbone with a continuous score-based diffusion model to generate high-quality trajectories for multiple robots. The framework, called Discrete-Guided Diffusion (DGD). Specifically, the first two stages mitigate the scalability challenge, and the next two stages address the challenge of constraint satisfaction and trajectory quality in high-dimensional spaces:

1. S1

Priority-based Convex Decomposition (PBD): approximation of the nonconvex free configuration space $\mathcal{C}_{\mathrm{f}}$ using nonoverlapping convex regions to enable problem decomposition (Section 4.1) 2. S2

Spatiotemporal assignment: determination of entry and exit events for each convex region by leveraging spatiotemporal dependencies extracted from a MAPF solution $\bm{\Pi}_{M}$ (Section 4.2). 3. S3

Diffusion-based Trajectory Generation: generation of high-quality trajectories for each subproblem using a diffusion model guided by $\bm{\Pi}_{M}$ (Section 4.3). 4. S4

Constraint-aware Diffusion Refinement: correction of infeasible trajectories through constraint-aware diffusion models by introducing a lightweight projection mechanism to enforce constraint satisfaction (Section 4.4).

Proofs for the theoretical results discussed in this section are referred to Appendix A.

4.1 Priority-Based Convex Decomposition

Recent advancements in single-robot planning replace the original nonconvex configuration space $\mathcal{C}_{\mathrm{f}}$ with a union of convex polytopes, enabling single-robot motion planning to be formulated as convex programs Werner et al. (2024a, b). The current state-of-the-art, the Visibility Clique Cover (VCC) algorithm Werner et al. (2024a), combines clique-based sampling with IRIS-style region inflation to approximate the free configuration space using a small number of large convex polytopes. While this eliminates nonconvex obstacle avoidance constraints, the resulting polytopes overlap heavily in practice. As shown in Figure 2(a), VCC produces substantially more sets than required to cover $\mathcal{C}_{\mathrm{f}}$, highlighting the inefficiency introduced by overlapping regions. For MRMP, this is problematic for two reasons: (i) First, overlap explodes the number of discrete mode switches that must be co-optimized, and (ii) Second, a single robot may lie in several polytopes at once, making a clean decomposition into independent subproblems impossible. This motivates us to find more compact and structure-aware representations.

Priority-based Decomposition (PBD).

To address these limitations, we introduce a novel decomposition approach that guarantees non-overlapping convex regions while optimizing for robot traffic patterns. This method builds upon computational geometry techniques, inspired by the Hertel-Mehlhorn algorithm Hertel and Mehlhorn (1983). It produces a partition $\mathcal{C}_{\text{f}}^{\text{c}}=\{R_{1},R_{2},\ldots,R_{k}\}$ where $R_{i}\cap R_{j}=\emptyset$ for $i\neq j$ and $\bigcup_{i=1}^{k}R_{i}\in\mathcal{C}_{\text{f}}$, ensuring each robot belongs to exactly one region at any time.

This eliminates the critical issue in overlapping methods, where a single point may belong to multiple regions, resulting in larger subproblems due to redundant coverage and making parallelization difficult, as subproblems are no longer independent. The decomposition is performed in two steps:

Triangulate $\mathcal{C}_{\mathrm{f}}$ in $O(|\mathcal{V}|\log|\mathcal{V}|)$ time, where $\mathcal{V}$ is a set of all vertices. 2. 2.

Iteratively remove diagonals to merge adjacent triangles, but prioritize edges that connect regions with the highest robot traffic according to the MAPF solution $\bm{\Pi}_{M}$.

The resulting Priority-Based Decomposition keeps the number of regions proportional to where the robots actually need maneuvering, dramatically reducing the downstream dimension required for diffusion, as illustrated in Figure 2(b). The detailed procedure is shown in Algorithm 1.

** Theorem​ 1**** (Sound, compact, and efficient).**

PBD outputs a finite set $\mathcal{C}_{\text{f}}^{\text{c}}$ of pairwise disjoint convex polygons satisfying $\bigcup_{R\in\mathcal{C}_{\text{f}}^{\text{c}}}R\in\mathcal{C}_{\mathrm{f}}$. Its runtime is $O(|\mathcal{V}|\log|\mathcal{V}|)$, where $\mathcal{V}$ are the vertices of the triangulation.

Sketch of Proof.

The runtime follows from (1) hole removal and triangulation in $\mathcal{O}(|\mathcal{V}|\log|\mathcal{V}|)$ time, and (2) at most $\mathcal{O}(|\mathcal{V}|)$ heap-based merge operations, each taking $\mathcal{O}(\log|\mathcal{V}|)$ time. ∎

** Remark​ 1**** (Region count).**

Empirically, PBD eliminates up to 32.6% of redundant convex regions across our benchmark scenarios. Compared to the baseline Visibility Clique Cover, it reduces the total number of region sets by over 50%, while also achieving faster runtime. This directly translates to a comparable reduction in the number of diffusion model calls required for trajectory generation.

4.2 MAPF-Driven Spatiotemporal Assignment

While PBD yields a non-overlapping spatial partition $\mathcal{C}_{\mathrm{f}}^{\mathrm{c}}=\{R_{1},\dots,R_{k}\}$, this alone is insufficient for decomposing MRMP. In multi-robot systems, coordination hinges not only on spatial separation but also on the spatiotemporal ordering of robot actions. Even when robots are assigned to disjoint regions, their trajectories can remain interdependent due to timing constraints. A central challenge lies in determining when and where each robot should enter or exit specific regions. These decisions introduce temporal coupling between otherwise spatially decoupled subproblems. Without resolving this temporal-spatial assignment, region-based planning cannot guarantee global feasibility.

To address this challenge, this paper makes a key observation: a discrete MAPF solution $\boldsymbol{\Pi}_{M}=\{\boldsymbol{\pi}_{m,i}\}_{i=1}^{N_{a}}$ inherently encodes a coarse spatiotemporal collision schedule. Thus, rather than leveraging $\boldsymbol{\Pi}_{M}$ for its specific paths, we extract and exploit its embedded coordination structure. Although MAPF operates in a discretized space-time domain, it effectively resolves collisions and preserves essential inter-agent dependencies. In particular, for each robot $a_{i}$ and region $R_{j}$, we extract two key events:

• •

Exit event: Time $t_{\text{out}}$ and position $\boldsymbol{\pi}_{\text{out}}$, sich that $\boldsymbol{\pi}_{m,i}(t_{\text{out}})\in R_{j}$ and $\boldsymbol{\pi}_{m,i}(t_{\text{out}}{+}1)\notin R_{j}$.

• •

Entry event: Time $t_{\text{in}}$ and position $\boldsymbol{\pi}_{\text{in}}$, such that $\boldsymbol{\pi}_{m,i}(t_{\text{in}})\in R_{k}$ and $\boldsymbol{\pi}_{m,i}(t_{\text{in}}{-}1)\notin R_{k}$.

From these, we construct a structured transition set: \mathcal{T}=\big{\{}\,(a_{i},R_{j},t_{\mathrm{out}},\boldsymbol{\pi}_{\mathrm{out}},R_{k},t_{\mathrm{in}},\boldsymbol{\pi}_{\mathrm{in}})\big{\}}, where each tuple indicates that agent $a_{i}$ exits region $R_{j}$ at $(t_{\mathrm{out}},\boldsymbol{\pi}_{\mathrm{out}})$ and enters region $R_{k}$ at $(t_{\mathrm{in}},\boldsymbol{\pi}_{\mathrm{in}})$. These transitions provide start and goal constraints for region-level diffusion models, enabling temporally consistent and spatially decoupled planning.

The transition set $\mathcal{T}$ is constructed by a single forward pass through the MAPF trajectories and the region map (see Algorithm 2 for details), as illustrated in S2 of Figure 1. Its structural utility is formalized as follows.

** Proposition​ 1**** (Valid subproblem decomposition).**

Fix any transition set $\mathcal{T}$ obtained from $\boldsymbol{\Pi}_{M}$ and $\mathcal{C}_{\text{f}}^{\text{c}}$. Then:

1. (a)

Each robot is uniquely assigned to one region $R\in\mathcal{C}_{\text{f}}^{\text{c}}$ at each time step. 2. (b)

Within each region $R$, the set of robot trajectories is temporally bounded by entry/exit events in $\mathcal{T}$. 3. (c)

There are no inter-region constraints at any time step, so each region defines an independent subproblem.

Sketch of Proof.

Disjointness of regions ensures spatial uniqueness. The time-based conditions in Algorithm 2 ensure that each robot’s regional assignment is temporally non-overlapping. Feasibility constraints in MRMP (e.g., inter-robot collision) only apply to robots simultaneously present in the same region. ∎

4.3 Diffusion-based trajectory generation

By decomposing the original problem into multiple independent subproblems, we are able to operate within smaller, decoupled subspaces. This improves runtime efficiency and sample quality. In this subsection, we describe how diffusion models are used to generate high-quality trajectories within each subproblem, as illustrated in S3 of Figure 1.

Diffusion modesl – preliminaries

Denoising Diffusion Probabilistic Models Sohl-Dickstein et al. (2015); Ho et al. (2020); Song et al. (2020) define a generative process by learning to reverse a forward stochastic transformation that progressively corrupts structured data into noise. The generative model then approximates the inverse of this transformation to restore the original structure, allowing sampling from the learned distribution. The diffusion model is thus trained to minimize the difference between the estimated and true scores of the perturbed data. Once trained, the score network $\bm{s}_{\theta}$ is used to denoise random samples $\bm{x}_{T}\sim\mathcal{N}(0,I)$ by iteratively updating $\bm{x}_{t}$ along the score direction until the samples resemble the original data. This is also known as the sampling phase, which follows the Stochastic Gradient Langevin Dynamics (SGLD) update rule:

[TABLE]

where $\epsilon$ denotes the step size and $z$ is standard Normal.

Trajectory Generation using Diffusion Models

To facilitate the generation of collision-free trajectories by diffusion models, a straightforward method is to bias the sampling process by incorporating gradient-based guidance to encourage the robot to avoid obstacles and other robots. This can be achieved by adding a penalty term into Eq. (2):

[TABLE]

where

[TABLE]

We define the obstacle and inter-agent penalty functions based on the squared L2-norm distance:

[TABLE]

where $d_{o}(\cdot)$ and $d_{a}(\cdot)$ measure the violation of minimum safety distances $r_{i,j}^{o}$ and $r_{i,j}^{a}$ between robot $a_{i}$ and obstacle $o_{j}$, and between robots $a_{i}$ and $a_{j}$, respectively. $\boldsymbol{\Pi}_{-i}$ denotes the set of trajectories of all robots except $a_{i}$.

Incorporating the penalty term into the sampling process allows the diffusion model to sample trajectories that follow the learned distribution while softly enforcing task requirements (e.g., collision avoidance). However, the guidance term alone does not guarantee that each trajectory remains within its assigned convex region, which is essential for maintaining independence across subproblems.

Fortunately, since each subproblem is defined over a convex domain, we can efficiently enforce this constraint by projecting each intermediate sample back onto the feasible set. To this end, we integrate a convex projection operator $\mathcal{P}_{\mathcal{C}_{\text{f}}^{c}}$ into the SGLD update rule with minimal computational overhead:

[TABLE]

where $\mathcal{P}_{\mathcal{C}_{\text{f}}^{c}}(\bm{x})=\arg\min_{\bm{y}\in\mathcal{C}_{\text{f}}^{c}}\|\bm{x}-\bm{y}\|_{2}^{2}$ denotes the Euclidean projection onto the feasible convex region $\mathcal{C}_{\text{f}}^{c}$ associated with the specific subproblem.

** Theorem​ 2**** (Obstacle avoidance).**

Let $\bm{x}_{0}$ denotes the trajectory generated by diffusion models with projection operator $\mathcal{P}_{\mathcal{C}_{\text{f}}^{c}}$. For arbitrary small $\xi$, there exist $t$ such that $\sum_{i=1}^{N_{a}}\nabla_{\bm{x}}d_{o}\left(\bm{x}_{0},\mathcal{O}\right)\leq\xi$.

Sketch of Proof.

Since $\mathcal{C}_{\text{f}}^{c}$ is a convex set, the projection operator $\mathcal{P}_{\mathcal{C}_{\text{f}}^{c}}$ guarantees that the generated trajectory lies within this feasible set Christopher et al. (2024). Moreover, since $\bigcup_{R\in\mathcal{C}_{\text{f}}^{c}}R\subseteq\mathcal{C}_{\text{f}}$, and $\mathcal{C}_{\text{f}}$ denotes the free configuration space, the generated trajectories satisfy the obstacle avoidance constraints. ∎

Additionally, beyond extracting timing structure, the MAPF plan $\boldsymbol{\Pi}_{M}$ provides a strong trajectory prior. Thus, inspired by recent work on Diffusion Models Inversion Meng et al. (2022); Rout et al. (2025), which shows that even an imperfect or suboptimal initial solution can lead to better performance than sampling from pure noise. Motivated by this, we adopt a similar strategy to improve sampling efficiency and quality. Unlike standard diffusion models that start from Gaussian noise $\bm{x}_{T}\sim\mathcal{N}(0,I)$, we leverage a valid but suboptimal solution from a MAPF solver to initialize the diffusion model’s reverse process $\bm{x}_{T}=\boldsymbol{\Pi}_{M}$, which provides a strong structural prior for the sampling process.

4.4 Constraint-aware Diffusion Refinement

The previous stages ensure that each trajectory remains within its assigned convex region and satisfies obstacle avoidance constraints. For inter-robot collision avoidance, although multiple guidance methods have been introduced to encourage generating collision-free trajectories, these mechanisms do not provide strict guarantees, especially with a large number of robots.

To address this limitation, we examine each region separately and introduce a Constraint-aware Diffusion refinement step to repair the infeasible subproblems, as shown in S4 of Figure 1. If any constraint in (1a)–(1b) is violated, we run a constraints-aware diffusion model to obatin the feasible solution. Specifically, we introduce anther projection operator $\mathcal{P}_{\boldsymbol{\Pi}}$ into the SGLD update rule:

[TABLE]

where

[TABLE]

To solve $\mathcal{P}_{\boldsymbol{\Pi}}$ more efficiently, we use a Lagrangian dual method, where the constraints are incorporated into a relaxed objective by using Lagrange multipliers $\nu$:

[TABLE]

To accelerate the convergence, a quadratic penalty term $\rho$ is introduced, and the augmented Lagrangian function is defined as:

[TABLE]

A dual ascent strategy is used to solve the relaxed problem, where the primal variable $\boldsymbol{x}^{\prime}$ is updated via gradient descent on the augmented Lagrangian $\mathcal{L}_{\text{alm}}(\bm{y},\boldsymbol{\nu})$, and the dual variable $\boldsymbol{\nu}$ is updated according to $\boldsymbol{\nu}\leftarrow\boldsymbol{\nu}+\rho\left\|\sum\nolimits_{i=1}^{N_{a}}\nabla_{\bm{y}}d_{a}\left(\bm{y}_{t}^{i},\bm{y}_{t}^{-i}\right)\right\|^{2}.$ The penalty coefficient $\rho$ is gradually increased to enforce the constraints more strictly. This iterative process continues until the residual of the collision avoidance constraints falls below a predefined threshold, at which point the algorithm returns a feasible trajectory.

** Remark​ 2****.**

Although inter-robot collision avoidance constraints are generally difficult to handle in MRMP due to their nonconvexity and high dimensionality, our approach focuses only on resolving such constraints within infeasible subproblems. These subproblems operate in significantly lower-dimensional spaces compared to the global problem. Moreover, by applying a Lagrangian relaxation, we further simplify the optimization landscape, making the constraint repair process highly efficient in practice.

5 Experiments

5.1 Experimental Setup

Settings.

To evaluate the performance of diffusion-based MRMP algorithms, we design two experimental settings targeting different aspects of the problem. (1) Feasibility, Efficiency, Quality: We adopt a diverse MRMP benchmark introduced in Liang et al. (2025), which includes four representative map types: random maps with varying obstacle densities (basic and dense), and structured maps mimicking real-world environments (room and shelf layouts). For each map type, we consider six robot counts (3, 6, 9, 12, 15, and 18), and evaluate across 25 instances with different configurations. Illustrations of the benchmark maps are included in the Figure 3. (2) Scalability: To evaluate the scalability of our method, we use a large-scale map containing over 100 heterogeneous obstacles. This setup supports scenarios with up to 100 robots, providing a challenging setting to examine the method’s ability to generate feasible plans in high-dimensional and cluttered environments.

Evaluation Metrics.

Different algorithms are empirically evaluated based on Success rate, Running time, Path Length, and Acceleration. The Success rate indicates the proportion of test cases solved without collisions and within the time limit (900 seconds), Running time measures the computational efficiency required to generate a solution, Path Length and Acceleration evaluate the quality of generated trajectories.

Competing Methods.

The proposed approach is compared against three SOTA diffusion-based baseline methods:

Motion Planning Diffusion (MPD): A state-of-the-art diffusion model for single-robot motion planning Carvalho et al. (2023), which we extend to the multi-robot setting for comparison. 2. 2.

Multi-robot Motion Planning Diffusion (MMD): A method that integrates diffusion models with a classical search-based MAPF algorithm to generate MRMP solutions under soft collision constraints Shaoul et al. (2024). 3. 3.

Simultaneous MRMP Diffusion (SMD): The current SOTA method recently introduced in Liang et al. (2025). It integrates diffusion models with constrained optimization to generate collision-free trajectories for MRMP.

The implementation details are provided in Appendix C.

5.2 Comparison across Methods

We evaluate the performance of all methods on the standard MRMP benchmark, comparing success rates, runtimes, and path lengths across scenarios of increasing complexity and robot count (6, 12, and 18 agents). Full results are summarized in Table 1, with additional metrics and ablations provided in Appendix B.

Baseline Performance

Motion Planning Diffusion (MPD) achieves the lowest runtimes and path lengths when successful. This is the case for the simplest problems (Basic maps with 6 robots). However, MPD fails to scale, consistently failing to generate feasible solutions beyond three robots in any more complex scenario. This underscores the limitations of unguided diffusion in multi-agent settings with tight coupling.

Multi-robot Motion Planning Diffusion (MMD) improves substantially over MPD by jointly modeling all agents. It maintains high success rates on Basic maps with up to 18 robots. However, its performance sharply degrades in more constrained environments. For instance, on Room and Shelf maps with 12 or more agents, MMD fails consistently. This breakdown is attributed to its lack of explicit coordination mechanisms, which leads to congestion and deadlocks in narrow passages.

Simultaneous MRMP Diffusion (SMD) shows high-quality planning with 100% success rates for up to 6 robots. However, its computational cost is orders of magnitude higher than other methods. For 12 or more robots, the running time becomes prohibitively long, and no solution is obtained within the imposed time limit.

Discrete Guided Diffusion (DGD)

DGD outperforms all baselines in both success rate and computational efficiency. By decomposing the MRMP problem into multiple region-level subproblems using a structured MAPF schedule, DGD solves each subproblem independently and in parallel, significantly reducing planning overhead. DGD attains over 92% success rate across all settings except the most challenging (Dense and Shelf maps with 18 robots), where it still leads with a success rate of 76%. Additionally, it achieves such results with lowest runtimes for the non-trivial benchmarks. Notably, on Dense maps with 6 robots, DGD matches SMD’s perfect success rate while using only 4% of its runtime.

DGD’s path lengths are comparable to those of MPD and MMD. While the average path length appears slightly higher, this is primarily because the averages are computed only over successful trials. In more challenging scenarios, where MPD and MMD often fail, DGD still succeeds, albeit with longer paths due to the complexity of the environment. Example trajectories generated by DGD are shown in Figure 4 and those for the baselines in Appendix B.

5.3 Scalability Analysis

To evaluate the scalability of DGD, we test it on large-scale environments containing a diverse mix of obstacle types within a single map. These environments feature 104 obstacles and 100 robots, substantially exceeding the complexity and scale of standard MRMP benchmarks.

As in earlier experiments, DGD decomposes the global MRMP problem into a set of independent subproblems, each confined to a convex region. This decomposition enables efficient parallelized planning, and allows DGD to scale gracefully to high-dimensional instances. Representative trajectories generated by DGD in this large-scale setting are shown in Figure 5 (figure cropped due to large size).

To the best of our knowledge, DGD is the first diffusion-based MRMP method capable of generating feasible solutions in environments with over 100 obstacles and 100 robots. In contrast to prior diffusion approaches, which have been demonstrated only on up to 40 robots in obstacle-free settings Shaoul et al. (2024), DGD achieves a 2.5$\times$ improvement in robot count while simultaneously addressing significantly more complex environments. This is significant: scalability is a key impediment to apply generative models to real-world multi-robot systems, where both geometric complexity and agent coordination pose significant challenges, and Thus, this works makes a significant step towards practical diffusion-based solvers for multi-robot planning.

5.4 Comparison between DGD and MAPF

We present a comparison between the MAPF solution and the trajectory generated by our DGD method for the same instance. As shown in Figure 6, the MAPF solution is restricted to a discrete grid, resulting in suboptimal paths with unnecessary turns and increased travel distance. In contrast, DGD generates trajectories with shorter path lengths while maintaining collision-free guarantees. For example, the highlighted blue robot follows a near-optimal straight-line path under DGD, whereas the corresponding MAPF trajectory is longer and more convoluted. This comparison illustrates that DGD not only benefits from the spatiotemporal guidance provided by the MAPF solution but also achieves higher-quality trajectories by operating in continuous space.

5.5 Limitation Anslysis

We believe that DGD offers strong potential for advancing multi-robot coordination. One limitation, however, lies in the relatively high acceleration occasionally observed in DGD-generated trajectories, which is caused by abrupt changes in velocity. Figure 7 shows a subset of trajectories generated by DGD on a dense map with 18 robots. The red dashed circles highlight two regions where robots undergo sharp velocity changes, corresponding to the green and orange robots. Gray dashed lines indicate the cropped boundary.

These discontinuities typically arise near the boundaries between adjacent convex regions and result from the absence of explicit consistency constraints across subproblems during trajectory generation. While DGD effectively generates collision-free trajectories by leveraging spatiotemporal priors, enforcing inter-region consistency is a promising direction for improving trajectory smoothness and physical realism. Despite such dynamics, DGD ensures collision-free paths by leveraging continuous-space generation guided by spatiotemporal priors.

6 Conclusion

This work introduces Discrete Guided Diffusion (DGD), a method that leverages a decomposition strategy to enable generative diffusion models to efficiently generate collision-free trajectories for multi-robot systems. By decomposing the original MRMP problem into multiple tractable subproblems, DGD alleviates the significant computational burden associated with large-scale MRMP. To address the spatiotemporal dependencies across multiple robots, MAPF solutions are employed to guide diffusion models in generating solutions for each subproblem. In addition, an efficient constraint repair mechanism ensures the feasibility of the generated trajectories.

Extensive experiments across varying obstacle densities and increasing robot counts demonstrate that DGD achieves significantly higher success rates and lower running times than competing methods. Experiments on large-scale maps further validate its scalability and robustness in handling both static obstacles and dynamic interactions, making it a promising approach for real-world applications.

While DGD achieves state-of-the-art performance on MRMP tasks, there are several promising directions to further enhance its capabilities. One opportunity lies in improving the decomposition process to produce more flexible subproblem partitions. In addition, extending the current framework to incorporate interactions between adjacent subregions could help better preserve temporal and spatial consistency across the full trajectory.

Acknowledgment

This research is partially supported by NSF grants 2334936, 2334448, 2533631, and NSF CAREER Award 2401285. The authors acknowledge Research Computing at the University of Virginia for providing computational resources that have contributed to the results reported within this paper. The views and conclusions of this work are those of the authors only.

Appendix A Missing Proof

A.1 Proof of Theorem 1

Proof.

We analyze the time complexity of the algorithm by examining its two main phases: Triangulation and Iterative Merging. Let $|\mathcal{V}|$ denote the number of vertices.

(i) Triangulation.

The main idea of triangulation is first to decompose the original nonconvex configuration space $C_{\text{f}}$ into simple polygons and then triangulate these simple polygons.

According to Theorem 3.6 in De Berg et al. [2008], the decomposition of an arbitrary simple polygon with $|\mathcal{V}|$ vertices into a set of y-monotone components can be executed in $O(|\mathcal{V}|\log|\mathcal{V}|)$ time. Once this decomposition is achieved, Theorem 3.7 in De Berg et al. [2008] establishes that each strictly y-monotone polygon admits a triangulation in linear time with respect to the number of its vertices.

Combining both stages, the overall computational complexity of triangulating $C_{\text{f}}$ is thus asymptotically dominated by the monotone decomposition step, yielding a total time complexity of $O(|\mathcal{V}|\log|\mathcal{V}|)$.

(ii) Iterative Merging.

Following triangulation, the algorithm enters a greedy, priority-guided region merging phase to produce a compact convex decomposition. Let $O(|\mathcal{V}|)$ denote the number of initial triangles. These serve as the base regions for merging.

The merging process is implemented via a max-heap data structure $\mathcal{H}$, which stores all admissible region pairs $(r_{1},r_{2})$ eligible for merging. Each element in $\mathcal{H}$ is keyed by a priority function $p(r)$ that encodes topological information. For each region $r\in R$, adjacency information is precomputed, leading to $O(|\mathcal{V}|)$ total adjacency relations, each inserted once into the heap during initialization.

Each successful merge operation reduces the total number of regions by exactly one. Thus, in the worst case, there are at most $O(|\mathcal{V}|)$ merges. Each merge operation requires a constant number of heap extractions and updates, each incurring a logarithmic overhead due to the heap structure. Therefore, the total cost of all merge operations is bounded above by .

Overall Complexity..

Combining both phases, the algorithm exhibits a worst-case runtime of $O(|\mathcal{V}|\log|\mathcal{V}|)$. ∎

A.2 Proof of Proposition 1

Proof.

Because $\{R_{j}\}$ is a partition of free space into disjoint convex regions, each robot position $\boldsymbol{\pi}_{m,i}(t)$ lies in exactly one region, so (a) holds.

Algorithm 2 records the first and last timesteps at which each robot enters and exits a region, which bounds its occupancy interval in that region and yields (b).

Finally, collision and feasibility constraints only involve robots sharing the same region at the same time; since no two robots coincide outside their recorded intervals, regions induce independent subproblems, giving (c). ∎

A.3 Proof of Theorem 2

Proof.

Beacause he projection operator $\mathcal{P}_{C_{\text{f}}^{c}}(\bm{x})$ performs the following convex optimization problem at each iteration:

[TABLE]

Since $C_{\text{f}}^{c}$ is convex and $\|\bm{x}-\bm{y}\|_{2}^{2}$ is convex and continuously differentiable over $C_{\text{f}}^{c}$, the optimization problem has a unique global minimum.

Let $Error$ be the distance between $\boldsymbol{x}_{t}$ and its nearest feasible point. Using Corollary 3 in Christopher et al. [2025], for any arbitrarily small $\xi>0$, there exists a time $t$ such that after the update:

[TABLE]

where $\mathcal{U}(\cdot)$ is the update operator defined by Langevin dynamics.

Therefore, the expected distance between the final generated trajectory and the feasible convex regions $C_{\text{f}}^{c}$ is bounded above by $\xi$, which means our DGD method yields a strictly smaller expected constraint violation and provides a feasibility guarantee for the convex constraint set $C_{\text{f}}^{c}$.

∎

Appendix B Additional Results

B.1 Detailed Comparison across Methods

We provide detailed results for all methods across four metrics: success rate, running time, path length, and acceleration. These results are presented in Table 2 and Table 3.

Table 2 presents the success rate (S) and running time (T) across all methods. Across all maps and agent counts, DGD maintains $100\%$ or near-$100\%$ success, even in the most challenging Room and Shelf settings with 18 robots. This highlights the strong generalization and feasibility enforcement of our method. DM fails to generate feasible trajectories in all but the easiest scenarios (3 robots). It yields zero success in nearly all settings with 6 or more robots, confirming its limited capacity to handle hard constraint satisfaction. While SMD occasionally matches DGD in success rate, it does so at significantly higher computational cost. For example, in the Basic map with 9 robots, both DGD and SMD reach $100\%$ success, but DGD requires $17.4$s while SMD takes over $500$s. DGD provides a favorable balance between running time and feasibility.

Table 3 reports the average path length (P) and acceleration (A) across different map types and robot counts. DGD consistently exhibits longer trajectories and higher acceleration compared to the baselines. This behavior is expected, as DGD is the only method capable of handling a broader range of challenging instances, particularly those involving dense environments and large robot teams. These instances naturally require longer paths due to more complex navigation requirements. The increased acceleration values are primarily caused by abrupt transitions between convex regions. Our current framework does not explicitly regulate these transitions, which can result in sharp velocity changes. Incorporating transition-aware smoothing or directly optimizing acceleration during inter-region movement is a promising direction for future work.

B.2 Example Trajectories for All Methods

We visualize example trajectories for each method on 18-robot instances, including only those where the method produced feasible solutions. Figure 8 shows the representative trajectories generated by DGD in 18 robot instances across the four types of maps. Figure 9 presents the corresponding results for MMD on basic and dense maps. For visualization purposes, we apply the Savitzky–Golay filter, which is widely used in multi-robot motion planning to smooth trajectories Shaoul et al. [2024].

We also present the full version of the results on the large map in Figure 10.

Appendix C Implementation Details

Software: The software used for experiments is Rocky Linux release 8.9, Python 3.8, Cuda 12.2, and PyTorch 2.1.2.

Hardware: For each of our experiments, we used the NVIDIA RTX A6000 GPU.

C.1 MRMP Details

In our experiments, the size of each local map was $2\times 2$ units. The robot radius was set to 0.04 units in all cases, except for the large-scale map, where it was 0.005 units. The obstacle sizes in basic and dense maps varied between 0.05 and 0.1 units.

C.2 Training Details

Our implementation builds upon the official code of Shaoul et al. [2024], Li et al. [2021], and Fratric [2025], with modifications to accommodate our specific requirements. Since MMD performs well in generating collision-free trajectories in obstacle-free environments, we leverage it to construct feasible trajectory datasets. Specifically, we first train MMD on single-robot motion planning tasks and then use it to generate multi-robot trajectories for training. Table 4 summarizes the hyperparameters used during training.