🤖 AI Summary
This paper addresses the reconfiguration of a distributed sliding block robot system—from an arbitrary edge-connected configuration to a connected rhombus shape—under minimal assumptions: a single leader, shared chirality, constant memory per robot, and local neighbor sensing and communication. We propose a spanning-tree-based distributed algorithm that, for the first time, resolves locked configurations without extending the original sliding move set. Two parallel variants are introduced: the first significantly accelerates reconfiguration; the second achieves linear average-case time complexity. The overall worst-case time complexity is $O(n^2)$, matching the sequential lower bound. Our key contributions are: (1) a proof of feasibility for connectivity-preserving reconfiguration under strong constraints; (2) a lock-breaking mechanism that requires no augmentation of the primitive move set; and (3) a parallelization framework that simultaneously attains theoretical optimality and practical efficiency.
📝 Abstract
The sliding square model is a widely used abstraction for studying self-reconfigurable robotic systems, where modules are square-shaped robots that move by sliding or rotating over one another. In this paper, we propose a novel distributed algorithm that allows a group of modules to reconfigure into a diamond shape, starting from an arbitrary side-connected configuration. It is connectivity-preserving and operates under minimal assumptions: one leader module, common chirality, constant memory per module, and visibility and communication restricted to immediate neighbors. Unlike prior work, which relaxes the original sliding square move-set, our approach uses the unmodified move-set, addressing the additional challenge of handling locked configurations. Our algorithm is sequential in nature and operates with a worst-case time complexity of $mathcal{O}(n^2)$ rounds, which is optimal for sequential algorithms. To improve runtime, we introduce two parallel variants of the algorithm. Both rely on a spanning tree data structure, allowing modules to make decisions based on local connectivity. Our experimental results show a significant speedup for the first variant, and linear average runtime for the second variant, which is worst-case optimal for parallel algorithms.