Break Loops: A Divide-and-Conquer Framework for Multi-Agent Path Finding for Large Agents Without Compromising Solvability

1. Introduction

In robotics and computer games, multiple agents often need to move simultaneously, and avoiding conflicts between agents has led to the study of Multi-Agent Path Finding (MAPF). MAPF aims to find a path for each agent from its start state to its target state on a given map, ensuring that no agents collide at any time. Numerous MAPF algorithms have been developed in recent years, such as Conflict-Based Search (CBS) [1], Priority-Based Search (PBS) [2], Priority Inheritance with Backtracking (PIBT) [3], and Lazy Constraints Addition for MAPF (LaCAM) [4].

Although previous MAPF algorithms have been applied in some real-world contexts [5,6,7], they are based on a simplifying assumption that limits their applicability. This assumption treats agents as point agents, which occupy exactly one cell at any time, ignoring their actual shape. In reality, agents are geometric with definite shapes (e.g., rectangular or circular), and typically occupy a set of points at any given time. Li et al. [8] refer to such agents as large agents. MAPF algorithms can be applied to large agents by lowering the resolution of the environment’s discretization. However, this approach degrades performance and reduces practical applicability. Therefore, Li et al. [8] formalize and study LA-MAPF, i.e., MAPF for large agents.

Empirical evidence indicates that LA-MAPF is more time-consuming than classic MAPF, as LA-MAPF needs more computational resources to determine whether two agents have conflicts (the definition of conflicts can be found in Section 3). For example, one of the SOTA (state-of-the-art) MAPF methods, LaCAM [4] (one of the fastest MAPF methods), is capable of solving a MAPF problem with 1000 agents in 60 seconds, whereas LA-LaCAM can only solve a LA-MAPF problem with 20 to 30 agents in 60 seconds (on the same map and computation platform). Therefore, reducing the time cost of solving the MAPF problem to enable LA-MAPF to find a solution involving more agents is crucial.

Motivated by the observation that the computational cost of optimally solving MAPF problems grows exponentially with the number of agents [9], we proposed a decomposition approach for MAPF problems [10] in our previous work. This method iteratively bipartitions MAPF problems until no smaller subproblems remain, as illustrated in Figure 1. Subsequently, all subproblems are solved independently and their solutions are merged to obtain a solution to the original problem. The merging is implemented by adding wait actions to ensure that solutions from different subproblems have no conflicts. Experimental results demonstrate that this decomposition significantly reduces the time cost and memory usage required to solve MAPF problems.

However, this approach has several limitations. First, it does not guarantee that every generated subproblem is solvable, which may cause the method to fail even on originally solvable MAPF instances. Second, the bipartition process considers only the agents within the current subproblem rather than all agents globally, leaving room for further decomposition into smaller subproblems.

To address these issues, we propose a novel framework for MAPF problem decomposition that is formulated as a combinatorial optimization problem. It considers all agents during the decomposition process, thereby enabling the generation of smaller subproblems. Inspired by Independence Detection [11], we further introduce a solvability safeguard to ensure that all generated subproblems are eventually solvable. In the worst case, the safeguard merges all subproblems back into the original problem and solves it using the underlying MAPF method.

The main contributions of this article are as follows:

1. We formulate the decomposition of LA-MAPF problems as a combinatorial optimization problem and solve it using a neighborhood search algorithm.

2. We propose a general framework that enables LA-MAPF methods to solve subproblems independently and merge their solutions into a conflict-free solution to the original problem. The framework includes a solvability safeguard mechanism that iteratively merges unsolvable subproblems until all subproblems become solvable.

3. We conduct extensive experiments to evaluate the effectiveness of the proposed decomposition across various maps and increasing numbers of agents. We assess its impact on LA-MAPF and MAPF methods in terms of computational time, success rate, and solution quality (makespan and sum of costs).

It is worth noting that MAPF is a simplified version of LA-MAPF; therefore, our framework can also be applied to standard MAPF problems. By replacing the conflict detection module in our framework with the conflict detection mechanism used in MAPF, the framework can be directly adapted to MAPF settings. However, some MAPF methods (e.g., LaCAM [4]) are already highly efficient and can handle MAPF instances with thousands of agents. As a result, applying our framework to such methods does not lead to significant performance improvements.

Consequently, in this manuscript, we mainly focus on LA-MAPF problems, where conflict detection between large agents is substantially more time-consuming. In this context, our framework can significantly reduce the overall computational cost. More detailed comparisons of our framework and LaCAM on both MAPF and LA-MAPF problems are presented in the Results section.

The remainder of this article is organized as follows. In the Related work section, we review related articles on the decomposition of MAPF problems. In the Preliminaries section, we introduce basic concepts and processes, followed by our method in the Methodology section. This section introduces how we decompose the MAPF problem into subproblems and merge their solutions to obtain a solution to the original problem. Our test results on the performance of the decomposition under various maps and different numbers of agents are presented in the Results section, along with an examination of how decomposition improves LA-MAPF methods. It also compares our new method with our previous method. Finally, the Conclusion section concludes the article.

2. Related Work

2.1. MAPF for Large Agents

Li et al. [8] generalized MAPF to LA-MAPF (MAPF for Large Agents), which considers the shapes of agents. In LA-MAPF, each agent has a fixed geometric shape around a reference point that cannot undergo transformations such as rotations. Therefore, different agents have different traversable subgraphs because of their different shapes. Li et al. [8] adapted CBS (Conflict-Based Search) to LA-CBS (CBS for Large Agents) to find a set of conflict-free paths that move all agents from their start vertices to their goal vertices while minimizing the sum of costs of all paths. To the best of our knowledge, this is the first study to focus on MAPF for agents with different shapes.

To accelerate LA-CBS, Zhang et al. [12] introduce mutex propagation and its concomitant symmetry-breaking to LA-CBS. The algorithm first finds mutexes between MDDs (Multi-Decision Diagrams) of a pair of agents via mutex propagation. Then, it uses these mutexes to identify and automatically resolve cardinal conflicts. The results show that this technique significantly improves the performance of some LA-CBS-based methods in terms of both success rate and runtime. Compared with this technique, our method is not limited to CBS-based methods but can be applied to any classic MAPF methods.

2.2. Related Work to LA-MAPF

Like LA-MAPF, Wen et al. [13] presented a mathematical formalization of the Multi-Agent Path Finding for Car-Like robots (CL-MAPF) problem. This approach considers both the position and orientation of car-like robots. It proposes a novel hierarchical search-based solver called Car-Like Conflict-Based Search to address this problem. It applies a body conflict tree to address conflicts while considering the shapes of the agents. It also introduces a new algorithm called Spatiotemporal Hybrid-State A* as the single-agent planner to generate agent paths satisfying both kinematic and spatiotemporal constraints.

Bai et al. [14] introduced the Heterogeneous Conflict Based Search (HCBS) algorithm as a solution to the Multi-Agent Pathfinding (MAPF) problem in nonholonomic heterogeneous robot scenarios. Leveraging the foundational principles of CBS, HCBS adapts to the diversity of robotic agents by implementing distinct path-planning strategies and incorporating a body conflict detection mechanism for conflict avoidance. Additionally, it introduces two suboptimal derivatives of HCBS—Enhanced HCBS (EHCBS) and Depth-First HCBS (DFHCBS), aimed at improving computational efficiency. While EHCBS tends to be less computationally efficient than HCBS in scenarios with fewer than 20 agents, owing to the overhead of managing additional focal lists, its performance surpasses that of HCBS in more densely populated maps. Conversely, DFHCBS consistently outperforms HCBS in terms of computational speed across all tested scenarios.

2.3. Existing Work on the Decomposition of MAPF Problems

The idea of splitting a MAPF problem into multiple smaller subproblems has been explored by researchers in recent years. Standley et al. [15,16] proposed that if the optimal paths of two agents have no conflicts (in classic MAPF, there are two types of conflicts: vertex conflict (i.e., node conflict), in which two agents visit the same node, and edge conflict, in which two agents visit the same edge in opposite directions; LA-MAPF’s conflict definition can be found in the Preliminaries section), they can be solved independently. Standley [16] introduced the Independence Detection (ID) algorithm to decompose a group of agents into the smallest possible groups. ID first assigns each agent to its own group and finds an initial path for each group independently. It then attempts to find alternative paths to avoid conflicts. If these attempts to find conflict-free paths fail, ID merges the conflicting groups. The process continues until there are no conflicts between agents from different groups.

While ID ensures the solvability of the decomposition, searching the full paths multiple times is very time-consuming. In contrast, our method reduces the time cost of decomposition by using a connectivity graph, which represents connections between regions, instead of cell-by-cell paths. Thus, our method is theoretically more efficient. Additionally, ID does not consider how the order of solving affects whether two agents are independent (e.g., by altering the order of solving, two agents can be solved separately, even if their isolated paths initially have conflicts).

Sharon et al. [17] proposed a continuum between CBS (Conflict-Based Search) and ID called Meta-Agent CBS (MA-CBS). MA-CBS introduces a predefined parameter B, where conflicting agents are merged into a meta-agent and treated as a joint composite agent if the number of conflicts exceeds B. The original CBS algorithm corresponds to the extreme case where B = ∞ (never merges agents), whereas the Independence Detection (ID) framework [15,16] represents the other extreme, where B = 0 (always merges agents when conflicts occur).

Prioritized Planning (PP) [18] decomposes a MAPF problem into multiple subproblems, each associated with a unique priority and containing a single agent. Paths are planned sequentially from the highest-priority agent to the lowest. For each agent, a path is computed that avoids static obstacles as well as the trajectories of higher-priority agents planned in earlier iterations. PP terminates with either success or failure within at most n iterations.

However, PP does not guarantee the existence of solutions that avoid both the start states of lower-priority agents and the regions occupied by higher-priority agents, rendering it incomplete.

To address this issue, Michal et al. [19] suggested well-formed infrastructures (i.e., limitations on the distribution of obstacles, start states, and target states) to ensure that the problem can be solved by priority-based search in all cases. A well-formed infrastructure is defined as one in which the endpoints (the start and target states of each agent) are distributed such that no agent standing on an endpoint can completely prevent other agents from moving between any two other endpoints.

Priority-Based Search (PBS) [2] is an incomplete, suboptimal algorithm designed for prioritized planning. At the high level, PBS employs a depth-first search to dynamically construct a priority ordering, forming a priority tree (PT). When a conflict occurs, PBS greedily assigns a higher priority to one of the agents involved. It efficiently backtracks and explores alternative branches only when no solution is found in the current branch. In this way, PBS incrementally builds a single partial priority ordering until all conflicts are resolved.

Once each agent is assigned a unique priority, PBS computes a minimum-cost path (in priority order) from the agent’s starting state to its target state, ensuring that it does not collide with the paths of higher-priority agents that have already been planned.

PBS ranks among the most efficient methods for solving MAPF. However, prioritized planning with an arbitrary priority ordering does not guarantee completeness or optimality in general [2]. In contrast, while our method cannot always solve each agent separately, it introduces a solvability safeguard to ensure that there is no unsolvable subproblem.

3. Preliminaries

In this section, we introduce the basic concepts of our framework.

3.1. Workspace

Definition 1. 

Workspace: An $\mathcal{N}$-dimensional Euclidean space ${\mathcal{C}}_{\mathcal{N}}$ (typically, $\mathcal{N}=2$ or 3). Each cell (or element) in ${\mathcal{C}}_{\mathcal{N}}$ can be in one of two states: passable or unpassable. The set of all passable cells is denoted by $\mathcal{F}$, and the set of all unpassable cells is denoted by $\mathcal{O}$.

3.2. Agent State

We define the agent state as a tuple of location and orientation.

Definition 2. 

Location: The location is a point in the Euclidean space ${\mathcal{C}}_{\mathcal{N}}$ and is specified by its coordinates $(p_0,p_1,\dots ,p_{\mathcal{N}-1})$, where $p_i\in \mathbb{Z}$ for $i=0,1,\dots ,\mathcal{N}-1$.

In an $\mathcal{N}$-dimensional Euclidean space, we define $2\mathcal{N}$ possible orientations. Each orientation is a unit vector along one of the coordinate axes.

For example:

• In a 2D space, the four possible orientations are $(1,0)$, $(-1,0)$, $(0,1)$, and $(0,-1)$ (i.e., east, west, north, south).
• In a 3D space, the six possible orientations are $(1,0,0)$, $(-1,0,0)$, $(0,1,0)$, $(0,-1,0)$, $(0,0,1)$, and $(0,0,-1)$ (i.e., east, west, north, south, up, down).

Definition 3. 

Agent Orientation: The orientation of an agent is defined as an integer r, where $r\in \{0,1,2,\dots ,2\mathcal{N}-1\}$. Each value of r corresponds to one of the $2\mathcal{N}$ possible orientations in an $\mathcal{N}$-dimensional space. Orientation is important with respect to shaped agents as changing orientation changes occupied grids.

For example:

• In a 2D space, $r=0$ corresponds to the orientation $(1,0)$, $r=1$ corresponds to $(-1,0)$, $r=2$ corresponds to $(0,1)$, and $r=3$ corresponds to $(0,-1)$.
• In a 3D space, $r=0$ corresponds to the orientation $(1,0,0)$, $r=1$ corresponds to $(-1,0,0)$, $r=2$ corresponds to $(0,1,0)$, and so on up to $r=5$, which corresponds to $(0,0,-1)$.

By considering orientation changes during planning, we can account for conflicts arising from these changes, making our solutions more realistic than those of approaches that consider only locations. Our approach thus makes solutions more transferable to real-world scenarios and makes them more convenient for execution.

Definition 4. 

Robot’s State  is defined as $s=\{(p_0,p_1,\dots ,p_{\mathcal{N}-1}),r\}$. For convenience, we denote the start state of agent $a_i$ as $S\left[a_i\right]$ and the target state as $T\left[a_i\right]$.

As mentioned by Li et al. [8], each agent has a fixed geometric shape centered around a reference point, which does not change position during rotations. We say that an agent is in state s when its reference point is located at the position specified by s, and its orientation matches the orientation defined in s.

3.3. Conflict Detection

Considering that different agents have different shapes, we define the process for checking whether agents collide with obstacles or with other agents. To facilitate conflict checks for arbitrary shapes, we discretize these shapes into cells. Next, we check whether the cells of the shapes overlap with the cells of the obstacles or the cells occupied by other agents’ shapes. Examples of this process are shown in Figure 2.

Considering that most agents are located far from other agents and obstacles during path planning, we introduce optimizations to avoid unnecessary conflict checks. We perform conflict detection between an agent and the map only if the agent’s distance to the nearest obstacle is between its circumcircle radius and its inscribed circle radius. Additionally, we perform conflict detection between agents only if the distance between their centers is between the sum of their circumcircle radii and the sum of their inscribed circle radii. If the distance is larger than the circumcircle radius, the configuration is guaranteed to be conflict-free; if the distance is smaller than the inscribed circle radius, a conflict is inevitable, and no further precise conflict detection is required.

Definition 5. 

We denote the cells occupied by agent $a_i$ at the robot state s as $[a_i,s]$ and the cell occupied by $a_i$ when it transitions from $s_1$ to $s_2$ as $[a_i,s_1,s_2]$. If $[a_i,s]\cap \mathcal{O}\ne \varnothing$, then agent $a_i$ at state s collides with obstacles. If $[a_i,s_1,s_2]\cap \mathcal{O}\ne \varnothing$, then agent $a_i$ collides with obstacles when it transitions from $s_1$ to $s_2$.

In the implementation, we do not explicitly compute $[a_i,s_1,s_2]$ during conflict detection. Instead, we precompute the cells occupied by each action (e.g., for a 2D MAPF problem, there are three actions: move forward, turn left, and turn right) of every agent during the initialization stage. Then, when conflict detection is required, we look up this table and apply a coordinate transformation to obtain $[a_i,s_1,s_2]$.

This conflict detection strategy may lose some details of the agents’ shapes; however, we adopt this approach to reduce the time cost of conflict detection, as conflict detection accounts for a major portion of the overall time cost of LA-MAPF.

3.4. Actions

To adapt to mobile platforms as much as possible, we only allow three types of actions: waiting at the current state, moving forward, or rotating by 90 degrees to an orthogonal direction. All actions have unit cost.

3.5. Subgraph of an Agent

As mentioned by Li et al. [8], different agents have different traversable subgraphs due to their varying shapes.

Definition 6. 

Subgraph $G_i=(V_i,E_i)$: A directed graph that represents all feasible states and valid transitions for agent $a_i$. The vertex set $V_i$ includes all collision-free agent states, and the edge set $E_i$ contains all collision-free transitions between states. Specifically, for every $v\in V_i$, the condition $[a_i,v]\cap \mathcal{O}=\varnothing$ must hold, meaning the agent does not collide with obstacles at state v. Similarly, for every directed edge $(v\to v^{\prime })\in E_i$, the transition satisfies $[a_i,v,v^{\prime }]\cap \mathcal{O}=\varnothing$, indicating no collision with obstacles during movement. Here, $v\in V_i$ denotes a vertex (state), and $(v\to v^{\prime })\in E_i$ denotes a valid transition from state v to $v^{\prime }$.

To ensure that a LA-MAPF problem is solvable, the start state and target state of each agent must be connected by at least one valid path within its subgraph. When constructing the subgraph, only the agent’s own geometric shape and the static map (i.e., the workspace) are considered—other agents are ignored during this phase. Two examples of such subgraphs are illustrated in Figure 3.

At each discrete timestep t, agent $a_i$ can either wait at its current state $v\in V_i$ or transfer to an adjacent state u, where $(v,u)\in E_i$.

Following the definitions in Li et al. [8], we generalize the concept of conflicts to accommodate agents with arbitrary shapes.

Definition 7. 

Vertex conflict: If $[a_i,u]\cap [a_j,v]\ne \varnothing$, we say that agent $a_i$ at state u has a conflict with agent $a_j$ at state v. Assuming that the current timestep is t, we define this conflict as a vertex conflict, represented by a five-element tuple: $\langle a_i,a_j,u,v,t\rangle$.

Similarly:

Definition 8. 

Edge conflict: If $[a_i,u_1,u_2]\cap [a_j,v_1,v_2]\ne \varnothing$, we say that agent $a_i$ and agent $a_j$ have an edge conflict when $a_i$ transfers from state $u_1$ to $u_2$ and $a_j$ transfers from state $v_1$ to $v_2$. Assuming that the current timestep is t, we represent an edge conflict by a seven-element tuple: $\langle a_i,a_j,u_1,u_2,v_1,v_2,t\rangle$.

Examples of vertex and edge conflicts are shown in Figure 4.

3.5.1. State Related to Another Agent’S Start / Target

Since large agents may occupy multiple cells, two large agents can experience conflicts even when they are in different states. This characteristic impacts path planning, particularly when agent $a_i$ attempts to avoid conflicts with agent $a_j$ while $a_j$ is at its start or target state. Because path planning is crucial in the decomposition of LA-MAPF problems, we formally define when a robot’s state in $a_i$’s subgraph is related to another agent’s start or target state.

Given two agents $a_i$ and $a_j$ and a node $v\in V_i,\forall v\to u\in E_i$, if $[a_i,v]\cap [a_j,S\left[a_j\right]]\ne \varnothing$, $[a_i,v,u]\cap [a_j,S\left[a_j\right]]\ne \varnothing$, $[a_i,v]\cap [a_j,T\left[a_j\right]]\ne \varnothing$, or $[a_i,v,u]\cap [a_j,T\left[a_j\right]]\ne \varnothing$, v is related to $a_j$’s start state or target state.

We denote nodes in $G_i(V_i,E_i)$ (the subgraph of an agent $a_i$) that are related to the start state of agent $a_j$ as $r_s(i,j)$ and nodes in $G_i(V_i,E_i)$ that are related to the target state of agent $a_j$ as $r_t(i,j)$. A related example is shown in Figure 5.

$$\begin{array}{cc}\hfill r_s(i,j)=& \left\{u\right|u\in V_i,[a_i,u]\cap [a_j,S\left[a_j\right]]\ne \varnothing \}\cup \hfill \\ \hfill & \left\{u\right|(u\to v)\in E_i,[a_i,u,v]\cap [a_j,S\left[a_j\right]]\ne \varnothing \}\cup \hfill \\ \hfill & \left\{v\right|(u\to v)\in E_i,[a_i,u,v]\cap [a_j,S\left[a_j\right]]\ne \varnothing \}\hfill \end{array}$$

$$\begin{array}{cc}\hfill r_t(i,j)=& \left\{u\right|u\in V_i,[a_i,u]\cap [a_j,T\left[a_j\right]]\ne \varnothing \}\cup \hfill \\ \hfill & \left\{u\right|(u\to v)\in E_i,[a_i,u,v]\cap [a_j,T\left[a_j\right]]\ne \varnothing \}\cup \hfill \\ \hfill & \left\{v\right|(u\to v)\in E_i,[a_i,u,v]\cap [a_j,T\left[a_j\right]]\ne \varnothing \}\hfill \end{array}$$

We denote the set of all start or target states of other agents related to an agent state u in $a_i$’s subgraph $G_i(V_i,E_i)$ as ${\mathcal{R}}_i\left(u\right)$. Therefore, if $\forall u\in r_s(i,j)$, we have $S\left[a_j\right]\in {\mathcal{R}}_i\left(u\right)$, and if $\forall u\in r_t(i,j)$, we have $T\left[a_j\right]\in {\mathcal{R}}_i\left(u\right)$.

An example of when a node in a subgraph is related to another agent’s start or target is shown in Figure 6.

3.6. Solvability Check for a LA-MAPF Problem

In the decomposition of a LA-MAPF problem, it is important to check whether a subproblem is solvable. Therefore, we propose a necessary condition but not sufficient method to check whether a subproblem is solvable. Before introducing this condition, we define a search path function as follows:

Definition 9. 

$search\_path(G_i(V_i,E_i),avoid\_node\_set)$: a complete method to search a path in $G_i(V_i,E_i)$ that connects the start state and target state of agent $a_i$. The parameter $avoid\_node\_set$ refers to the set of nodes that cannot be part of the path. If a solution exists, we denote this as $search\_path(G_i(V_i,E_i),avoid\_node\_set)\ne \varnothing$.

$search\_path$ can be implemented using Best-First Search or Breadth-First Search.

Definition 10. 

Solvability check: $\forall a_i\in A$, if $search\_path(G_i(V_i,E_i),\varnothing )\ne \varnothing$, the MAPF problem might be solvable; otherwise, it is unsolvable.

An example of how to check whether a simple MAPF problem is solvable is shown in Figure 7. If a MAPF problem fails to meet this condition, it must be unsolvable, as there is at least one agent that has no path connecting its start and target states even when other agents are ignored; however, if a problem meets this condition, it might be unsolvable, since the presence of other agents may prevent a feasible solution; an example is shown in Figure 8. Similarly, if a LA-MAPF problem fails to meet this condition, it must be unsolvable; however, if a LA-MAPF problem meets this condition, it might be unsolvable.

This means our method may decompose a solvable problem into unsolvable subproblems. Therefore, our framework introduces a solvability safeguard when detecting unsolvable solving subproblems (failed to find solution within a given time threshold). The solvability safeguard ensures all subproblems are solvable by merging unsolvable subproblems with other subproblems until all subproblems are solvable. More details about the solvability safeguard can be found in Section 4.

3.7. Component Connectivity Graph

Since our primary concern in the solvability check is whether an agent’s path passes through nodes that are related to the start or target states of other agents, we first identify which nodes in the subgraph are related to other agents’ start or target states (i.e., their relationships with other agents). Then, we apply strongly connected component (SCC) detection to partition the node set $V_i$ into subsets, where each subset contains nodes that share the same relationship with other agents’ start and target states. Furthermore, all nodes within a subset are mutually reachable.

We say a component is related to an agent if it contains nodes related to that agent. Similarly, a component is considered related to an agent’s start or target state if it contains nodes related to that specific state. A Strongly Connected Component (SCC) is a fundamental concept in graph theory. In a directed graph, an SCC is a maximal subset of nodes such that every node is reachable from every other node in the same subset via directed paths.

In the implementation, we use Tarjan’s algorithm  [20] for SCCs detection and ignore edges between nodes that have different relationships with other agents to ensure that nodes within the same component have the same relationships with other agents. Specifically, the start and target states of the agent of the current subgraph are treated as two nodes in the connectivity graph, as they are the start and target of the path search.

Definition 11. 

We define the directed graph in which nodes are SCCs of the subgraph $G_i^c(V_i,E_i)$ that ignore edges between nodes that have different relationships with agents, and edges represent whether a component is connected to another component as the component connectivity graph $G_i^c(V_i^c,E_i^c)$.

In the decomposition of the LA-MAPF problem, we focus primarily on whether an agent has a relationship with other agents’ start or target states, and $G_i^c(V_i^c,E_i^c)$’s nodes are connected components of $Gi(V_i,E_i)$; all nodes in the same component have the same relationship with other agents. Therefore, for any path in $G_i(V_i,E_i)$, there is a path in $G^{c}i(V_i^c,E_i^c)$ that has the same relationship with agents, and vice versa. A path in $G{i}^c(V^{c}i,E^{c}i)$ that does not pass through any component related to another agent $a_j$’s start or target state is equivalent to a path in $G_i(V_i,E_i)$ that does not pass through any node related to agent $a_j$’s start or target state. Thus, we can search for paths in $G^c(V^{c}i,E^{c}i)$ rather than in $G_i(V_i,E_i)$.

In the implementation, we can simplify the component connectivity graph to minimize its scale by ignoring components that have no relationship with other agents or do not contain the start state or target state of the current agent and by directly connecting the nodes that were connected through them. For example, if there are three nodes $v\to v^{\prime }\to u$ in a subgraph’s component connectivity graph and $R_i\left(v^{\prime }\right)=\varnothing$, we can connect v and u directly, $v\to u$, as ignoring $v^{\prime }$ has no influence on determining whether one agent’s path is related to another agent’s start or target state. An example of a connectivity graph is shown in Figure 9.

We denote a path in the component connectivity graph as a dependency path, and it reveals whether two agents could be in different subproblems (i.e., one agent does not depend on another) and the order in which to solve them.

3.7.1. Variant of $Search\_path$: $Search\_path\_ST$

To reduce the computational cost of the $search\_path$ function during the decomposition of the LA-MAPF problem, we leverage the fact that $G_i^c(V_i^c,E_i^c)$ is smaller than $G_i(V_i,E_i)$. Based on this, we propose an optimized variant of the path search function: $search\_path\_ST$$(G_i^c(V_i^c,E_i^c),$$avoid\_ST\_set)$.

$search\_path\_ST$ returns a dependency path that involves the fewest possible start or target states, subject to the constraints of $avoid\_ST\_set$. The $avoid\_ST\_set$ parameter specifies the sets of start states and target states, respectively, that the dependency path is not allowed to be related to.

$search\_path\_ST$ searches for a dependency path that is related to the fewest start or target states, and returns the related start and target states of the resulting path. If multiple such paths exist, it returns one of them arbitrarily.

Here, we provide several examples to demonstrate how the function $search\_path\_ST$ operates. For the simplified component connectivity graph shown in Figure 10, the following results are obtained:

• $search\_path\_ST(G_1^c,\varnothing )$ returns one of the following sets: $\{S1,S2,T2,T1\}$, $\{S1,S3,T3,T1\}$, $\{S1,S3,T2,T1\}$, or $\{S1,S2,T3,T1\}$, as there are four valid paths involving the minimum number of agent dependencies.
• $search\_path\_ST(G_1^c,T2)$ returns either $\{S1,S3,T3,T1\}$ or $\{S1,S2,T3,T1\}$, as these paths avoid the specified dependency on $T2$.
• $search\_path\_ST(G_1^c,S2,S3)=\varnothing$, since agent $a_1$ must traverse through either $S2$ or $S3$ to reach its target.

For any dependency path generated by $search\_path\_ST$, $search\_path$ produces the same dependency path. Considering $search\_path\_ST$ is more computationally efficient than $search\_path$, we adopt $search\_path\_ST$ to search for dependency paths.

3.8. Definition of Decomposition of an LA-MAPF Problem

There are two major requirements for the decomposition of an LA-MAPF problem: (1) each subproblem should be solvable independently; that is, solving one subproblem should not require modifying the solutions of other subproblems; (2) once all subproblems are solved, their combined solutions form a conflict-free solution to the original MAPF problem. We propose a simplified scenario to satisfy these two requirements.

3.8.1. A Simplified Scenario

In the simplified scenario, agents in each subproblem start moving only after all agents in the previous subproblems have reached their target states, while avoiding the start states of subsequent subproblems. In other words, each subproblem treats agents from other subproblems as static obstacles, as illustrated in Figure 11. If a solution can be found for every subproblem under this scenario, then by combining these solutions, we obtain a conflict-free overall solution. Note that some agents may need to wait at their start states for a period to guarantee the final solution is conflict-free. An example is shown in Figure 16. If all subproblems pass the solvability check under this scenario, we say that a legal decomposition of the LA-MAPF problem has been found.

Before introducing our method for decomposing the LA-MAPF problem, we first define the concept of decomposition of the LA-MAPF problem based on the simplified scenario.

Definition 12. 

Decomposition of a MAPF problem:splitting a set of k agents, $A=\{a_1,a_2,\dots ,a_k\}$, where $k\ge 1$, into m disjoint subsets $A_1,A_2,\dots ,A_m$, where $m\ge 1$ and $A_1\cup A_2\cup \dots \cup A_m=A$. For any $i\ne j$, we have $A_i\cap A_j=\varnothing$.

For each subset $A_i$, we construct a subproblem in which the impassable cells are defined as ${\mathcal{O}}^{\prime }=\mathcal{O}\cup T\left[A_j\right]\cup S\left[A_k\right]$, where $j<i$ and $k>i$. Here, $T\left[A_j\right]$ and $S\left[A_k\right]$ denote the cells occupied by the target states of previous subproblems and the start states of subsequent subproblems, respectively.

Thus, the original MAPF problem is decomposed into multiple subproblems, each of which can be solved in a manner similar to a regular MAPF problem.

3.9. Determine Subproblems from Dependency Paths

In this section, we introduce how we determine subproblems from the dependency paths of all agents. The solvability check condition determines whether a decomposition into subproblems is legal; it also identifies which subproblems are legal for agents’ dependency paths. In other words, we could determine subproblems from agents’ dependency paths.

• If $a_i$’s dependency path passes $a_j$’s start state, $a_i$ should be solved later than $a_j$ if they are in different subproblems, because $a_j$ must leave its start state first. We denote this condition as $a_j\to a_i$.
• If $a_i$’s dependency path passes $a_j$’s target state, $a_i$ should be solved earlier than $a_j$ if they are in different subproblems, because $a_j$ hasn’t reached its target state yet. We denote this condition as $a_i\to a_j$.
• If $a_i$’s dependency path passes neither $a_j$’s start state nor target state, there is no solving order limitation.

Agents’ dependency paths determine the solving order between agents, and the solving order of agents determines subproblems. To determine subproblems from agents’ relations (whether one agent should be solved earlier or later than another agent), we propose a graph representing all agents’ solving orders.

Definition 13. 

Solving order graph $G_s$: a directed graph where nodes are agents and edges represent relations between agents. If $a_i\to a_j$, there is an edge $a_i\to a_j$ in the graph.

If we set subproblems as all SCCs in $G_s$, every subproblem’s agents’ will meet the solving order constraints between agents. Thus, we obtain subproblems via SCCs detection from $G_s$. The order of solving subproblems is determined by the edges connecting them. If there is no edge between two components, there is no solving order limitation for them.

Intuitively, a subproblem corresponds to a loop in $G_s$. For example, given three agents $a_1,a_2,a_3$, with $a_1\to a_2$, $a_2\to a_3$, and $a_3\to a_1$, these agents form a loop in the corresponding $G_s$, so they belong to the same subproblem. Thus, if we can break loops in $G_s$ without introducing larger loops (by updating dependency paths), we can reduce the maximum subproblem sizes and achieve better decomposition.

Consider the component connectivity graph in Figure 12. If $a_1,a_2,a_3,a_4$ have dependency paths $S1,T1,S2,T3$, $S2,T2,S3$, $S3,T3,T2$, and $S4,T4,S3$ respectively, the corresponding $G_s$ is shown in Figure 13A, where $a_1,a_2,a_3$ form a loop and thus belong to the same subproblem. However, replacing $a_1$’s dependency path with $S1,T1,S2,S3$ yields the $G_s$ in Figure 13B; the loop is broken, resulting in each subproblem containing only one agent ($a_1,a_2,a_3,a_4$), i.e., a better decomposition.

For a MAPF problem with k agents, each agent’s dependency path can include or exclude the start and target states of the other $k-1$ agents, resulting in at most $2^{2(k-1)}$ possible dependency paths per agent. Therefore, if we consider the dependency paths of all k agents as variables to optimize, the total number of possible combinations is at most $2^{2k(k-1)}$.

Thus, it is almost impossible to traverse all possible combinations of dependency paths and determine the one that generates the optimal decomposition. Essentially, this is a combinatorial optimization problem, so it is feasible to solve it via methods for solving classic combinatorial optimization problems. In the Methodology section, we introduce how we use neighborhood search (a method to solve combinatorial optimization problems) to decompose LA-MAPF problems. More details can be found in Section 4.

4. Methodology

In this section, we introduce how we decompose an LA-MAPF problem into subproblems, how we solve all subproblems with a solvability safeguard and merge their solutions to obtain a conflict-free solution for the original problem. Moreover, we analyze the completeness and suboptimality of LA-MAPF methods under our problem decomposition.

4.1. Decompostion of LA-MAPF Problem

4.1.1. Break Loops

As mentioned in the Preliminaries section, we treat decomposition of LA-MAPF problem as a combinatorial optimization problem. The variables we optimize are all agents’ dependency paths (denoted as $\mathcal{P}$). The optimization goal is to minimize the size of the largest subproblem (i.e., the largest loop in $G_s$). We define the neighborhood of $\mathcal{P}$ as the set of all ${\mathcal{P}}^{\prime }$ that differ from $\mathcal{P}$ by exactly one agent’s dependency path. We define the $G_s$ of $\mathcal{P}$ as $G_s\to \mathcal{P}$ and the largest loop in $G_s$ as ${\left[G_s\right]}^{*}$.

Initially, we obtain initial dependency paths (i.e., initial solution) by implementing using $search\_path\_ST$ and set $avoid\_ST\_set=\varnothing$. Then we select a random agent from ${\left[G_s\right]}^{*}$, and attempt to update its dependency path to break the loop it is in and avoid introducing extra loops. If $search\_path\_ST$ succeeds and the new dependency path reduces the size of the max loop, update $\mathcal{P}$. Then repeat this loop-breaking process until a termination condition.

The terminate condition consists of three criteria: 1. Reaching the time limit (e.g., 5 s or 10 s); 2.A continuous series of failed loop-breaking attempts reaches a threshold count (e.g., 50 or 100); 3. The total number of loop-breaking attempts reaches a threshold (e.g., 1000). The terminate condition aims to avoid wasting too much time on failed attempts to break loops.

In detail, the $avoid\_ST\_set$ should be set to the start states of agents in earlier subproblems and the target states of agents in subsequent subproblems; otherwise, the new dependency path may introduce new loops, as illustrated in Figure 14A.

To break a loop, we must remove either the incoming edges (from other agents in the loop to the current agent) or the outgoing edges (from the current agent to other agents in the loop), as illustrated in Figure 14B. In the implementation, we randomly select either incoming or outgoing edges to attempt breaking the loop. To ensure these edges are broken, the $avoid\_ST\_set$ must also include the target states of agents corresponding to the incoming edges or the start states of agents corresponding to the outgoing edges, accordingly.

Here, we provide an example to demonstrate how loop breaking works. For the solving order graph $G_s$ shown in Figure 12, suppose the initial dependency paths of agents $a_1,a_2,a_3,a_4$ are $\{S1,T1,S2,T3\}$, $\{S2,T2,S3\}$, $\{S3,T3,T2\}$, and $\{S4,T4,S3\}$, respectively. The resulting $G_s$ is shown in Figure 13A, where $a_1$, $a_2$, and $a_3$ form a loop. To break the loop, we select agent $a_1$ and consider its outgoing edges to other agents in the same loop. Accordingly, the $avoid\_ST\_set$ is set to $\{S4,T3\}$. We then compute $search\_path\_ST(G_1^c,\{S4,T3\})=\{S1,T1,S2,S3\}$. By replacing $a_1$’s dependency path with this new path, the updated $G_s$ becomes Figure 13B. The loop is successfully broken, resulting in a better decomposition.

4.1.2. Implementation

In this section, we provide details about implementation of breaking loops.

The decomposition based on break loops is presented in Algorithm 1. The algorithm proceeds as follows:

• Lines 1–4: initial dependency paths and $G_s$;
• Lines 5–12: break loops iteratively until a terminate condition is met;
• Lines 13–14: return all SCCs in $G_s$ as results of decomposition.

Algorithm 1: Decomposition_of_MAPF_problems

4.2. Solving Subproblems and Combine Their Solution

In this section, we present our approach for solving subproblems independently with a solvability safeguard to handle unsolvable cases, and describe the merging process of all subproblem solutions to obtain a conflict-free global solution.

4.2.1. Solving Subproblems with Solvability Safeguard

In solving subproblems, they are processed sequentially while avoiding conflicts with both previous subproblems’ target states and subsequent subproblems’ start states. However, as previously mentioned, the solvability check condition may incorrectly classify unsolvable subproblems as solvable, potentially resulting in some unsolvable subproblems.

To preserve solvability, motivated by ID [11], we propose a solvability safeguard with four components:

• When detecting an unsolvable subproblem (failed to find a solution within a time limit, e.g., 60 seconds), we solve it while ignoring other subproblems’ agents (allowing conflicts with other agents’ start or target states). Since the original LA-MAPF subproblem is assumed solvable, part of it remains solvable.
• We verify whether the solution conflicts with: previous subproblems’ target states, or subsequent subproblems’ start states (the solution must satisfy at least one of: 1) conflict with a previous subproblem’s start state; 2) conflict with a subsequent subproblem’s target state, otherwise, it is solvable (if the raw problem is solvable) while avoiding conflicts with both previous subproblems’ target states and subsequent subproblems’ start states).
• We merge all subproblems between the affected previous and subsequent subproblems into a new subproblem to replace all merged subproblems, creating a new LA-MAPF subproblem decomposition.
• We attempt to solve the subproblems in this new decomposition.

After merging, all subproblems still pass the legality check. In the worst-case scenario, all subproblems may merge into a single problem - reverting to the original problem formulation. This guarantees that our solvability safeguard can always prevent loss of solvability.

4.2.2. Merge Solution

After solving all subproblems and obtaining their solutions, we merge them to construct a conflict-free global solution. As established in the simplified scenario, each subproblem’s solution avoids both: previous subproblems’ target states and subsequent subproblems’ start states. Thus, we can always guarantee a conflict-free solution by inserting wait actions at each subproblem’s solution until all agents from previous subproblems reach their targets. This approach ensures the solution is conflict-free in worst-case scenarios, though potentially at the cost of additional wait actions when agents could otherwise begin moving earlier without conflicts.

To optimize solution quality, we propose an improved merging method:

• Initialize at $t=0$
• For each subproblem: 1) determine necessary wait actions at the current timestep to avoid conflicts with previous subproblems’ solutions; 2) track the maximum required wait duration
• Apply the maximum wait actions to all paths in the current subproblem to prevent: conflicts with prior solutions and intra-subproblem path conflicts
• $t=t+1$, iterate until all solutions are conflict-free.

There are two types of MAPF methods.

• In the first type, the same joint state of all agents is allowed to occur more than once in a solution, as in EECBS.
• In the second type, the same joint state of all agents is not allowed to occur more than once, such as in LaCAM. More details on how LaCAM forbids the same configuration from occurring again can be found in its implementation1.

The first type is complete in terms of avoiding conflicts with external paths (i.e., paths of agents not included in the current subproblem). In contrast, the second type is not complete in this sense, because all agents may need to wait at their current states to avoid conflicts with external agents’ paths, but such waiting is forbidden.

We refer to the first type of MAPF methods as p-complete methods, and the second type as p-incomplete methods. When solving subproblems, p-complete MAPF methods can treat the paths of agents from other subproblems as constraints to be avoided. As a result, no additional wait actions are required during solution merging, since the subproblem solutions are already mutually conflict-free.

In contrast, p-incomplete MAPF methods cannot incorporate external paths as constraints. Therefore, adding wait actions during the merging of subproblem solutions is necessary to ensure a conflict-free global solution.

4.2.3. Implementation

In this section, we present the implementation details for solving subproblems and merging their solutions.

The subproblem-solving process with solvability safeguard is presented in Algorithm 2. The algorithm proceeds as follows:

• Lines 1–10: sequentially solve all subproblems
• Lines 11–18: apply the solvability safeguard by merging unsolvable subproblems with other subproblems and solving subproblems in the new decomposition
• Lines 19–20: stores solutions for the current subproblems
• Lines 21–25: merges subproblem solutions (skipped for p-complete methods, as their solutions inherently avoid conflicts with other subproblems’ solutions)

A toy example about the solvability safeguard is shown in Figure 15.

Algorithm 2: Solving_subproblems

The merging algorithm proceeds through three key phases, as shown in Algorithm 3:

• Conflict Detection (Lines 1–13): 1) verifies whether the current subproblem’s path conflicts with previous subproblems’ solutions; 2) performs pairwise collision checks at each timestep
• Wait Time Calculation (Lines 14–18):
  1) computes required wait durations when conflicts are detected;
  2) maintains the maximum necessary wait time across all conflicts;
  3) applies temporal padding to ensure safe separation
• Solution Integration (Lines 19–30):

  –

  Path Modification (Lines 19–28): a) inserts calculated wait actions into unfinished paths; b) ensures all current subproblem paths are conflict-free

  –

  Solution Aggregation (Lines 29–30): a) incorporates modified solutions into the merged plan; b) returns the complete conflict-free solution after processing all subproblems

Algorithm 3: Merge_solutions

The merging process is illustrated in Figure 16, showing both the temporal adjustments and final coordinated solution.

Figure 16. This figure shows a LA-MAPF problem containing two agents (Figure A) that belong to different subproblems and the subproblems’ solutions (Figure B), and how to merge them into a conflict-free solution (Figures C∼H).

Figure 16. This figure shows a LA-MAPF problem containing two agents (Figure A) that belong to different subproblems and the subproblems’ solutions (Figure B), and how to merge them into a conflict-free solution (Figures C∼H).

4.3. Completeness and Suboptimality

Besides efficiency, our major focus, completeness and optimality are two important aspects in the evaluation of MAPF methods. Therefore, in this section, we discuss the completeness of MAPF methods under our problem decomposition, and the suboptimality of the resulting solutions.

4.3.1. Completeness

Although the solvability check may misjudge an unsolvable LA-MAPF problem as solvable, and may decompose a solvable problem into unsolvable subproblems, we introduce a solvability safeguard to ensure all subproblems are solvable. In the worst case, all subproblems are merged back into the original problem and solved by the MAPF method that the framework uses. Therefore, if a complete MAPF method is combined with our MAPF problem decomposition, the resulting approach remains complete.

4.3.2. Suboptimality

In this section, we discuss the suboptimality of the merged solution in the worst case. In summary, since we need to add wait actions when merging solutions of subproblems, the solution produced by our framework is unboundedly suboptimal in the worst case (an example of a bounded-suboptimal MAPF method is EECBS [21]). We analyze both the makespan and the sum of costs in the worst case. The proof consists of two steps: we first discuss how many wait actions each subproblem solution needs to add, and then analyze how many wait actions are introduced in the merged solution.

As the merging solution needs to add wait actions so that the solution is conflict-free, decomposition of the MAPF problem affects the solution quality. Here, we analyze how the decomposition of a MAPF problem affects the makespan and the sum of costs in the best and worst cases.

In the best case, when paths of different subproblems have no conflicts, no wait actions are needed, so decomposition has no side effects. According to empirical evidence, this situation usually arises when the agents are sparsely distributed.

However, when the agents are densely distributed, the merging solution may need to add many wait actions. For quantitative analysis, we assume that a LA-MAPF problem has k agents and n subproblems $A_1,A_2,\dots ,A_n$. We denote the makespan and the sum of costs of subproblem $A_i$ after merging as $m^{\prime }\left[i\right]$ and $s^{\prime }\left[i\right]$. The makespan and sum of costs of the total solution before merging are M and S, respectively, and those after merging are $M^{\prime }$ and $S^{\prime }$, respectively. In the worst case, each subproblem’s solution needs waiting actions that are equal to the maximum makespan of the previous subproblems’ solutions (i.e., waiting until all previous subproblems’ agents have reached their targets), because all previous agents remain at their target states.

$$M=\underset{i}{argmax}m\left[i\right]$$

$$m^{\prime }\left[i\right]=m\left[i\right]+{\sum }_{j=1}^{i-1}m\left[j\right]={\sum }_{j=1}^{i}m\left[j\right]$$

$$M^{\prime }=\underset{i}{argmax}{m}^{\prime }\left[i\right]=m^{\prime }\left[n\right]={\sum }_{j=1}^{n}m\left[j\right]$$

In the worst case, the last subproblem has the largest makespan, as it needs to wait until the agents of all previous subproblems reach their targets.

$$S={\sum }_{i=1}^{n}s\left[i\right]$$

$$s^{\prime }\left[i\right]=s\left[i\right]+\left|A_i\right|{\sum }_{j=1}^{i-1}{m}^{\prime }\left[j\right]$$

In the worst case, the increase in every subproblem’s solution is the product of the current subproblem’s size and the sum of the sizes of all previous subproblems.

$$S^{\prime }={\sum }_{i=1}^n{s}^{\prime }\left[i\right]={\sum }_{i=1}^{n}s\left[i\right]+{\sum }_{j=1}^n\left|A_j\right|{\sum }_{k=1}^{j-1}{m}^{\prime }\left[k\right]$$

$$=S+{\sum }_{j=1}^n\left|A_j\right|{\sum }_{k=1}^{j-1}m\left[k\right]$$

Denote $\underset{i}{argmin}m\left[i\right]=m^{*}$.

$$M^{\prime }-M={\sum }_{j=1}^{k}m\left[j\right]-\underset{i}{argmax}m\left[i\right]\ge (n-1)m^{*}$$

$${\displaystyle \frac{M^{\prime }-M}{M}}\ge {\displaystyle \frac{(n-1)m^{*}}{\underset{i}{argmax}m\left[i\right]}}$$

The first subproblem has the smallest makespan in the worst case, so $\underset{i}{argmin}{m}^{\prime }\left[i\right]=m^{\prime }\left[1\right]$. As the first subproblem’s solution does not need to wait, $m^{\prime }\left[1\right]=m\left[1\right]$.

$$S^{\prime }-S={\sum }_{j=1}^n|A_j|{\sum }_{k=1}^{j-1}{m}^{\prime }\left[k\right]\ge {\sum }_{j=1}^n\left|A_j\right|{\sum }_{k=1}^{j-1}{m}^{\prime }\left[1\right]$$

$$={\sum }_{j=1}^n|A_j|(j-1)m\left[1\right]=m\left[1\right]{\sum }_{j=1}^n\left|A_j\right|$$

Denote $\underset{i}{argmin}|A_i|=|A^{*}|$.

$$S^{\prime }-S\ge \left|A^{*}\right|m\left[1\right]{\sum }_{j=1}^n(j-1)={\displaystyle \frac{|A^{*}|m\left[1\right]n(n-1)}{2}}$$

$${\displaystyle \frac{S^{\prime }-S}{S}}={\displaystyle \frac{n(n-1)|A^{*}|m\left[1\right]}{2{\sum }_{i=1}^{n}s\left[i\right]}}$$

${\displaystyle \frac{M^{\prime }-M}{M}}$ and ${\displaystyle \frac{S^{\prime }-S}{S}}$ reflect how much worse the merged solution can be; the larger these values are, the worse the solution. These two values depend on multiple factors, such as the number of subproblems, the minimum makespan of the subproblem solutions, and the minimum subproblem size; therefore, they have no finite upper bound. Therefore, in the worst case, the merging process may produce a suboptimal and unbounded solution, even when an optimal LA-MAPF solver such as LA-CBS is used.

5. Results

In this section, we evaluate the performance of our framework, Break Loops (BL), on both MAPF and LA-MAPF problems. We compare BL with Independence Detection (ID), our previous bipartition-based decomposition method (BP), and the raw MAPF methods. The comparison metrics include time cost, success rate, makespan, and sum of costs to assess overall performance. We also conduct an ablation study to examine how each component contributes to Break Loops. As Break Loops contains two phases: (1) initialization of subproblems and (2) iteratively breaking loops to obtain smaller subproblems, we add Break Loops initialization (BI) to the evaluation.

Additionally, we compare max subproblem size, number of subproblems, and decomposition time cost to evaluate the decomposition approaches (BL, BP, and ID). Specifically, since ID does not separate the process into two distinct phases—decomposition followed by planning—as BL and BP do, only the decomposition time costs of BL and BP are compared.

As a common practice in solving MAPF problems, we set an upper bound of 60 seconds on the time cost. Methods that are complete but fail to find a solution within the given time limit are considered failures.

To ensure a fair comparison on solution quality, we only consider cases in which both methods are successful.

So, we compared the solution quality of methods pair by pair, such as raw CBS and CBS with ID, LaCAM with BP, and LaCAM with BL.

We select 10 maps from the classic MAPF benchmark dataset2 [22,23] as test environments. To evaluate how problem decomposition scales with the number of agents, we vary the number of agents from 10 to 1000 (or the maximum number allowed by the map, as some smaller maps may not support 1000 agents). For each agent count, 100 random instances are generated.

Since MAPF is essentially a simplified version of LA-MAPF, our framework can also be applied to MAPF problems. Therefore, we evaluate its performance on both MAPF and LA-MAPF instances.

For LA-MAPF problems, to the best of our knowledge, no public dataset is currently available. Hence, we randomly generate LA-MAPF problems for experimentation. These problems include two types of agents: circular agents and rectangular agents, each with randomly assigned sizes. The radii of the circular agents range from 0.4 to 2.0 cells, while the widths and lengths of the rectangular agents range from 0.4 to 4.0 cells. An example of a map and a corresponding LA-MAPF problem is shown in Figure 17.

For the MAPF methods, we apply CBS and LaCAM. CBS is an optimal MAPF algorithm, while LaCAM is one of the fastest MAPF methods currently available. For experiments on LA-MAPF, we extend CBS and LaCAM to LA-CBS (CBS for large agents) and LA-LaCAM, following the implementation guidelines in [8]. Below, we provide a brief introduction to both CBS and LaCAM.

Conflict-Based Search (CBS) [1] stands out as one of the most well-known MAPF methods. It is characterized by its completeness and optimality. CBS is a two-level algorithm. At the high level, a search is performed on a tree based on conflicts between agents. At the low level, a search is performed for a single agent at a time. The algorithm updates each agent’s path in isolation at the low level while avoiding all constraints set by the high-level tree. The algorithm exits when it finds a conflict-free solution or all nodes in the high-level tree have been expanded and no new nodes are available. We apply CBS with mutex propagation for comparison [12].

LaCAM [4] is a complete but suboptimal two-level MAPF method. At the high level, it explores a sequence of configurations, where each search node corresponds to a specific configuration. A configuration represents the current locations of all agents. At the low level, LaCAM searches for constraints that determine where each agent should move in the next configuration. If successful, the resulting configuration is added to the high-level search. If no new configurations can be generated, the algorithm terminates with failure.

LaCAM is p-incomplete, as it updates the states of all agents simultaneously at each step. Its implementation forbids repeated configurations, which limits its ability to resolve conflicts with external paths in the same way as CBS. Consequently, we only evaluate Independence Detection (ID) in combination with CBS, and do not test ID with LaCAM.

Given the large number of figures used to present the results, we summarize the key findings in tables placed in the main body of the paper. Details of how the performance of different methods varies with the number of agents are provided in the Appendix.

All experiments were conducted on a computer running Ubuntu 20.04, equipped with a 2.5 GHz CPU and 128 GB of RAM. All implementations were written in C++.

5.1. Application on MAPF

5.1.1. CBS

In this section, we focus on the comparison between raw CBS and CBS enhanced with our Break Loops (BL) framework. A summary of the results is presented in Table 1, Table 2 and Table 3, while detailed results are illustrated in Figure A1 and Figure A2.

As shown in these tables and figures, raw CBS becomes increasingly time-consuming as the number of agents increases, leading to a lower success rate. In contrast, CBS with BL significantly reduces the time cost and achieves a higher success rate, as expected. Some results are shown in Figure 18. However, CBS with problem decomposition yields suboptimal solutions. This is because merging the solutions of subproblems often requires inserting wait actions to ensure global consistency, whereas CBS is an optimal solver when applied directly.

5.1.2. LaCAM

In this section, we focus on the comparison between raw LaCAM and LaCAM combined with the Break Loops (BL) framework. A summary of the results is presented in Table 4, Table 5 and Table 6, while detailed results are illustrated in Figure A3 and Figure A4

As shown in these tables and figures, raw LaCAM is highly efficient on most maps, and the time cost of problem decomposition using BL is comparable to that of raw LaCAM. Therefore, BL provides little benefit in these cases. However, on maps where LaCAM incurs higher time costs than the decomposition overhead (e.g., (1) warehouse-10-20-10-2-1 and (2) warehouse-20-40-10-2-1), BL effectively reduces the total time cost and improves the success rate. Some results are shown in Figure 19.

Similar to CBS, LaCAM with problem decomposition produces lower-quality solutions. This is because merging subproblem solutions requires inserting additional wait actions to ensure a conflict-free global solution.

5.2. Application on LA-MAPF

5.2.1. LA-CBS

In this section, we focus on the comparison between raw LA-CBS and LA-CBS enhanced with the Break Loops (BL) framework. A summary of the results is presented in Table 7, Table 8 and Table 9, while detailed results are illustrated in Figure A5 and Figure A6.

As shown in these tables and figures, similar to CBS, raw LA-CBS is time-consuming and thus exhibits a lower success rate as the number of agents increases. In contrast, LA-CBS with BL significantly reduces the time cost and achieves a higher success rate. Some results are shown in Figure 20. However, LA-CBS with problem decomposition yields lower-quality solutions. This is because merging subproblem solutions often requires adding wait actions to ensure a conflict-free overall plan, and raw LA-CBS is an optimal method.

5.2.2. LA-LaCAM

In this section, we focus on the comparison between raw LA-LaCAM and LA-LaCAM with the Break Loops (BL) framework. A summary of the results is presented in Table 10, Table 11 and Table 12, while detailed results are illustrated in Figure A7 and Figure A8.

As shown in these tables and figures, unlike LaCAM, LA-LaCAM is more time-consuming due to the overhead of conflict detection between large agents. As the number of agents increases, its success rate decreases accordingly. In this case, applying BL significantly reduces the time cost of LA-LaCAM, leading to a higher success rate. Some results are shown in Figure 21. However, similar to previous observations, LA-LaCAM with problem decomposition produces lower-quality solutions. This is because merging subproblem solutions often requires inserting wait actions to ensure a conflict-free final plan.

5.3. Comparison between ID, BP and BL

In this section, we focus on the comparison between raw LA-LaCAM and LA-LaCAM with the Break Loops (BL) framework. A summary of the results is presented in Table 1, Table 4, Table 7, and Table 10, while detailed results are shown in Figure A1, Figure A2, Figure A3, Figure A4, Figure A5, Figure A6, Figure A7 and Figure A8.

In terms of time cost, ID incurs a higher time cost compared to BL and BP, and it also exhibits a lower success rate. The main reasons are as follows:

• ID does not consider the order in which subproblems are solved, whereas both BP and BL do. Consequently, the layered decomposition used in BL is more likely to divide a MAPF problem into smaller and more manageable subproblems.
• When ID attempts to verify whether a group (i.e., a subproblem) can avoid conflicts with another group, it does not prevent previously resolved conflicts from occurring again between the two groups. As a result, ID may fall into infinite loops. For example, suppose Group A is modified to avoid conflicts with Group B. Later, a conflict between Group A and Group C is detected, prompting ID to update Group A’s solution to avoid Group C. However, this new solution may reintroduce conflicts with Group B. ID will then repeat the process of resolving conflicts with Groups B and C, potentially leading to a loop that continues until the time limit is reached. This issue is rare when agents are sparse but becomes frequent in densely populated scenarios.
• In BL and BP, each agent is involved in the multi-agent pathfinding process only once. In contrast, in ID, an agent may participate multiple times, as it can be merged into different groups at various stages. This repeated involvement increases the overall time cost of ID compared to BP and BL.

Compared to BP, BL has a lower decomposition time cost, smaller maximum subproblem size, and a larger number of subproblems. As a result, MAPF with BL requires less overall computation time and achieves a higher success rate. This improvement is mainly due to two factors: (1) BP considers only the agents within the current subproblem during decomposition, while BL takes all agents into account; and (2) BL explicitly aims to minimize the size of the largest subproblem at every step, whereas BP does not. These differences enable BL to produce a better decomposition more efficiently.

5.4. Ablation Study

To evaluate the contribution of each component in our framework, we conduct an ablation study, which compares Break Loops with only initialization (BI) and Break Loops (BI) in the experiments. The related results can be found in Table 1, Table 4, Table 7, and Table 10 and Figure A1, Figure A2, Figure A3, Figure A4, Figure A5, Figure A6, Figure A7 and Figure A8.

As shown in the above results, on maps with sparse agents (e.g., MAPF: Berlin_1_256 and Boston_0_256; LA-MAPF: Berlin_1_256 and Boston_2_256), BI can decompose the original problem into very small subproblems, so there is no significant difference between the performance of BI and BL, as shown in Figure 22 and Figure 23. However, on maps with dense agents (e.g., MAPF: empty-32-32 and random-32-32-20; LA-MAPF: empty-32-32 and empty-48-48), BL uses the optimization technique to decompose the original problem into much smaller subproblems, thereby reducing the time cost and increasing the success rate. In summary, compared to BI, BL has a smaller time cost and a higher success rate on average. The initialization of BL plays a major role on maps with sparse agents, while the optimization technique plays a major role on maps with dense obstacles.

5.5. Summary

In summary, our framework significantly reduces the time cost and improves the success rate of CBS, LA-CBS, and LA-LaCAM. For LaCAM, BL does not improve performance when its time cost is close to the decomposition time cost. However, BL can still enhance LaCAM’s performance when LaCAM requires more time than BL’s decomposition process. Our framework also demonstrates significant advantages over our previous method BP and over Independence Detection (ID), including smaller maximum subproblem sizes, a larger number of subproblems, lower time cost, and higher success rates. Nevertheless, the effectiveness of BL, BP, and ID decreases as the number of agents increases.

6. Conclusions and Discussion

Since each agent occupies multiple cells, solving LA-MAPF (Large-Agent Multi-Agent Path Finding) becomes increasingly time-consuming as the number of agents grows. Motivated by the exponential increase in computational cost with the number of agents, we propose Break Loops, a divide-and-conquer framework for accelerating MAPF algorithms.

Our method employs neighborhood search to iteratively reduce the size of the largest subproblem until a time or iteration limit is reached. Each resulting subproblem is then solved independently, ensuring that agents avoid the target states of earlier subproblems and the start states of later ones. To guarantee solvability, we introduce a safeguard mechanism: when an unsolvable subproblem is detected, it is merged with others until all subproblems become solvable. Finally, the solutions to all subproblems are combined into a conflict-free solution of the original problem.

The experimental results demonstrate that our framework is highly effective for solving LA-MAPF problems. Compared to raw LA-MAPF methods, applying our framework significantly reduces time cost and improves success rate. Furthermore, Break Loops outperforms both Independence Detection and our previous decomposition-based approach. Although our framework can also be applied to classic MAPF problems, it may not yield substantial time savings when the underlying MAPF method is already highly efficient (e.g., LaCAM).

Despite its benefits, Break Loops has limitations: its effectiveness diminishes as the number of agents increases. Nevertheless, even in the worst case—when the problem cannot be decomposed into smaller subproblems—its performance is never worse than that of the raw LA-MAPF methods.

In future work, we plan to apply LA-MAPF decomposition to real-world scenarios, thereby extending our framework to practical applications. We will also focus on optimizing the decomposition process, as there is still room for improvement— for example, by solving multiple subproblems concurrently on parallel threads.

7. Reproducibility Checklist for JAIR

Select the answers that apply to your research – one per item.

All Articles:

• All claims investigated in this work are clearly stated. [yes]
• Clear explanations are given how the work reported substantiates the claims. [yes]
• Limitations or technical assumptions are stated clearly and explicitly. [yes]
• Conceptual outlines and/or pseudo-code descriptions of the AI methods introduced in this work are provided, and important implementation details are discussed. [yes]
• Motivation is provided for all design choices, including algorithms, implementation choices, parameters, data sets and experimental protocols beyond metrics. [yes]

Articles Containing Theoretical Contributions:

Does this paper make theoretical contributions? [yes/no]

If yes, please complete the list below.

• All assumptions and restrictions are stated clearly and formally. [yes]
• All novel claims are stated formally (e.g., in theorem statements). [yes]
• Proofs of all non-trivial claims are provided in sufficient detail to permit verification by readers with a reasonable degree of expertise (e.g., that expected from a PhD candidate in the same area of AI). [yes]
• Complex formalism, such as definitions or proofs, is motivated and explained clearly. [yes]
• The use of mathematical notation and formalism serves the purpose of enhancing clarity and precision; gratuitous use of mathematical formalism (i.e., use that does not enhance clarity or precision) is avoided. [yes]
• Appropriate citations are given for all non-trivial theoretical tools and techniques. [yes]

Articles Reporting on Computational Experiments:

Does this paper include computational experiments? [yes]

If yes, please complete the list below.

• All source code required for conducting experiments is included in an online appendix or will be made publicly available upon publication of the paper. The online appendix follows best practices for source code readability and documentation as well as for long-term accessibility. [yes]
• The source code comes with a license that allows free usage for reproducibility purposes. [yes]
• The source code comes with a license that allows free usage for research purposes in general. [yes]
• Raw, unaggregated data from all experiments is included in an online appendix or will be made publicly available upon publication of the paper. The online appendix follows best practices for long-term accessibility. [yes]
• The unaggregated data comes with a license that allows free usage for reproducibility purposes. [yes]
• The unaggregated data comes with a license that allows free usage for research purposes in general. [yes]
• If an algorithm depends on randomness, then the method used for generating random numbers and for setting seeds is described in a way sufficient to allow replication of results. [yes]
• The execution environment for experiments, the computing infrastructure (hardware and software) used for running them, is described, including GPU/CPU makes and models; amount of memory (cache and RAM); make and version of operating system; names and versions of relevant software libraries and frameworks. [yes]
• The evaluation metrics used in experiments are clearly explained and their choice is explicitly motivated. [yes]
• The number of algorithm runs used to compute each result is reported. [yes]
• Reported results have not been “cherry-picked” by silently ignoring unsuccessful or unsatisfactory experiments. [yes]
• Analysis of results goes beyond single-dimensional summaries of performance (e.g., average, median) to include measures of variation, confidence, or other distributional information. [yes]
• All (hyper-) parameter settings for the algorithms/methods used in experiments have been reported, along with the rationale or method for determining them. [yes]
• The number and range of (hyper-) parameter settings explored prior to conducting final experiments have been indicated, along with the effort spent on (hyper-) parameter optimisation. [yes]
• Appropriately chosen statistical hypothesis tests are used to establish statistical significance in the presence of noise effects. [yes]

Articles Using Data Sets:

Does this work rely on one or more data sets (possibly obtained from a benchmark generator or similar software artifact)? [yes]

If yes, please complete the list below.

• All newly introduced data sets are included in an online appendix or will be made publicly available upon publication of the paper. The online appendix follows best practices for long-term accessibility with a license that allows free usage for research purposes. [yes]
• The newly introduced data set comes with a license that allows free usage for reproducibility purposes. [yes]
• The newly introduced data set comes with a license that allows free usage for research purposes in general. [yes]
• All data sets drawn from the literature or other public sources (potentially including authors’ own previously published work) are accompanied by appropriate citations. [yes]
• All data sets drawn from the existing literature (potentially including authors’ own previously published work) are publicly available. [yes]
• All new data sets and data sets that are not publicly available are described in detail, including relevant statistics, the data collection process and annotation process if relevant. [yes]
• All methods used for preprocessing, augmenting, batching or splitting data sets (e.g., in the context of hold-out or cross-validation) are described in detail. [yes]