Pebble Motion on Graphs with Rotations: Efficient Feasibility Tests and Planning Algorithms

We study the problem of planning paths for $p$ distinguishable pebbles (robots) residing on the vertices of an $n$-vertex connected graph with $p \le n$. A pebble may move from a vertex to an adjacent one in a time step provided that it does not collide with other pebbles. When $p = n$, the only collision free moves are synchronous rotations of pebbles on disjoint cycles of the graph. We show that the feasibility of such problems is intrinsically determined by the diameter of a (unique) permutation group induced by the underlying graph. Roughly speaking, the diameter of a group $\mathbf G$ is the minimum length of the generator product required to reach an arbitrary element of $\mathbf G$ from the identity element. Through bounding the diameter of this associated permutation group, which assumes a maximum value of $O(n^2)$, we establish a linear time algorithm for deciding the feasibility of such problems and an $O(n^3)$ algorithm for planning complete paths.

💡 Research Summary

The paper addresses the classic multi‑robot path planning problem on a connected graph $G=(V,E)$ with $|V|=n$ vertices and $p\le n$ distinguishable robots (pebbles). A robot may move to an adjacent vertex in one time step provided that no two robots occupy the same vertex simultaneously. When $p=n$, every vertex is occupied, so the only collision‑free moves are synchronous rotations of robots along vertex‑disjoint cycles of the graph. The authors observe that such rotations generate a permutation group $\mathbf G$ uniquely determined by the underlying graph.

The central theoretical contribution is a tight bound on the diameter of $\mathbf G$, defined as the smallest number $d$ such that any element of $\mathbf G$ can be expressed as a product of at most $d$ generators (the generators being the elementary rotations on each simple cycle). By decomposing $G$ into a spanning tree $T$ and a cycle basis ${C_1,\dots,C_k}$, they show that any permutation of the robots can be realized by at most $O(n^2)$ elementary rotations, i.e., $\operatorname{diam}(\mathbf G)=O(n^2)$. This bound is dramatically smaller than the naïve exponential bound that follows from the size of the symmetric group $S_n$ and is essential for algorithmic design.

Using the diameter bound, the authors develop two algorithms.

1. Feasibility Test (Linear Time).
   Given an initial placement $P_{\text{src}}$ and a target placement $P_{\text{tgt}}$, they compute the induced permutation $\pi$ that maps each robot’s current vertex to its goal vertex. The test reduces to checking whether $\pi$ belongs to $\mathbf G$. Because $\mathbf G$ is generated by the rotations on the cycle basis, $\pi$ can be expressed as a product of those generators in at most $O(n^2)$ steps. The authors present a constructive procedure that, by projecting $\pi$ onto each cycle and using the spanning tree to resolve conflicts, decides feasibility in $O(n+m)$ time (where $m$ is the number of edges).

2. Complete Path Planning (Cubic Time).
   When feasibility is confirmed, the algorithm explicitly constructs a sequence of synchronous rotations that drives the system from $P_{\text{src}}$ to $P_{\text{tgt}}$. For each cycle $C_i$, the required number of rotations $r_i$ (mod $|C_i|$) is computed from the cycle decomposition of $\pi$. Because cycles that are vertex‑disjoint can rotate simultaneously, the authors formulate a scheduling problem: partition the set of cycles into maximal families of non‑intersecting cycles and apply the corresponding rotations in parallel. Using a greedy coloring or matching on the conflict graph of cycles, they obtain a schedule whose total number of rotation steps is bounded by $O(n^2)$. Since each rotation on a cycle of length $|C_i|$ can be simulated in $O(|C_i|)$ time, the overall runtime is $O\bigl(\sum_i |C_i|,r_i\bigr)=O(n^3)$. The algorithm is provably complete: the produced schedule never creates a collision and always reaches the target configuration.

The paper situates its results within the broader literature on token swapping, the 15‑puzzle, and multi‑robot motion planning. For tree graphs, the permutation group collapses to the identity, and the feasibility test reduces to the known linear‑time algorithms for tree‑based pebble motion. For graphs rich in cycles, the new $O(n^2)$ diameter bound yields the first polynomial‑time feasibility test and a practical planning algorithm that scales cubically with the graph size.

Beyond the theoretical analysis, the authors discuss practical implications. The approach is directly applicable to dense warehouse environments, automated parking structures, and network routing scenarios where every node is occupied and only coordinated cyclic shifts are possible. Moreover, the group‑theoretic perspective opens avenues for future work: (i) tightening the diameter bound for special graph families (planar graphs, bounded‑genus graphs) potentially to $O(n\log n)$ or $O(n)$; (ii) extending the model to allow weighted edges or asynchronous rotations; (iii) designing distributed versions of the algorithm where each robot decides locally based on limited information.

In summary, the paper makes three major contributions: (1) it identifies the permutation group induced by graph rotations as the fundamental structure governing feasibility; (2) it proves a tight $O(n^2)$ upper bound on the group’s diameter, thereby converting an otherwise intractable decision problem into a linear‑time test; and (3) it leverages these insights to construct a complete, polynomial‑time path‑planning algorithm with $O(n^3)$ runtime. The work bridges combinatorial group theory and algorithmic robotics, offering both deep theoretical insight and concrete tools for real‑world multi‑robot coordination.