Efficient Distributed Algorithms for Shape Reduction via Reconfigurable Circuits

TL;DR

The paper studies efficient distributed algorithms for size-changing transformations of 2D shapes using reconfigurable circuits for fast communication and collision-aware operations. It develops multiple reduction strategies in two models (connectivity and adjacency), achieving polylogarithmic runtimes: BFS shrinking to a single node in $O(k \log n)$ rounds, incompressible reductions in $O(\log n)$ when incompressible nodes are known, and topological reductions in $O(k \log n + \log^2 n)$ rounds, with $O(\log n)$ preprocessing. It also establishes lower bounds showing limits of shrinking-only approaches, e.g., $\Omega(k \log k)$ and $\Omega(\log^2 n)$, and extends results to the adjacency model with a $O(\log n)$-round single-node reduction. The findings highlight how reconfigurable-circuit-based communication enables collision-free, fast parallel size-changing transformations, with potential impact on programmable matter, swarm robotics, and dynamic networks. Overall, the work advances understanding of distributed control for active self-assembly under geometry-constrained, size-changing dynamics.

Abstract

Autonomous reconfiguration of agent-based systems is a key challenge in the study of programmable matter, distributed robotics, and molecular self-assembly. While substantial prior work has focused on size-preserving transformations, much less is known about size-changing transformations. Such transformations find application in natural processes, active self-assembly, and dynamical systems, where structures may evolve through the addition or removal of components controlled by local rules. In this paper, we study efficient distributed algorithms for transforming 2D geometric configurations of simple agents, called shapes, using only local size-changing operations. A novelty of our approach is the use of reconfigurable circuits as the underlying communication model, a recently proposed model enabling instant node-to-node communication via primitive signals. Unlike previous work, we integrate collision avoidance as a core responsibility of the distributed algorithm. We consider two graph update models: connectivity and adjacency. Let $n$ denote the number of agents and $k$ the number of turning points in the initial shape. In the connectivity model, we show that any tree-shaped configuration can be reduced to a single agent using only shrinking operations in $O(k \log n)$ rounds w.h.p., and to its incompressible form in $O(\log n)$ rounds w.h.p. given prior knowledge of the incompressible nodes, or in $O(k \log n)$ rounds otherwise. When both shrinking and growth operations are available, we give an algorithm that transforms any tree to a topologically equivalent one in $O(k \log n + \log^2 n)$ rounds w.h.p. On the negative side, we show that one cannot hope for $o(\log^2 n)$-round transformations for all shapes of $Θ(\log n)$ turning points. In the adjacency model, we show that any connected shape can reduce itself to a single node using only shrinking in $O(\log n)$ rounds w.h.p.

Figures (13)

• Figure 1: (a) An initial shape $S_I$. (b) Left: green nodes apply a growth operation each adding a new adjacent node (a copy of the green node). Right: the result after the growth translates the second part of the shape one unit to the east. (c) Left: green nodes apply a shrinking operation, each being absorbed and removed by their adjacent node in the shrinking direction. Right: the result after the shrinking translates the second part one unit to the west.
• Figure 2: The figure, originally from DBLP:journals/tcs/AlmalkiM24, illustrates examples of node collisions. (a) Initial tree $T$. (b) The tree $T'$ after a growth operation on node $u$ moves north to generate a new node $u'$ without any collision. (c) Illustration of a node collision scenario: $T'$ here is a result of a growth operation applied on node $u$ toward the east, where a node $v$ already exists and $uv\notin E$. The newly generated node $u'$ occupies the same position as $v$, leading to a node collision. (d) Another scenario of a node collision: two nodes $u_1$ and $u_2$ simultaneously grow in the east direction and generate $u_1'$ and $u_2'$, though $u_1'$ and $u_2'$ do not collide directly, their growth pushes their branch into an adjacent branch, leading to a collision. These scenarios are analogous in the context of shrinking operations.
• Figure 3: This figure, as presented in DBLP:conf/algosensors/AlmalkiGM24, shows an example of a cycle collision within the shape $S$ due to unequal displacement vectors along the two paths $p_1$ and $p_2$, thus, $\vec{v}_{p_1}\neq \vec{v}_{p_2}$. In particular, the number of generated nodes (gray nodes) along $p_2$ is greater than that along $p_1$. This difference in the number of generated nodes leads to a collision within the cycle, indicating an irregularity in the shape $S'$.
• Figure 4: Example of an execution of the PASC algorithm. Note that the nodes are depicted as rectangles and the external links are reduced to a single nodes. The reference node $u_r = u_4$ is marked by a blue border. The yellow nodes are active while the gray nodes are passive. The partition sets marked by a P (S) are the primary (secondary) partition sets. The nodes receive the beep on the red partition sets. Figure adapted from DBLP:journals/nc/PadalkinSW24.
• Figure 5: An illustration of the segment detection subroutine which shows the parallel circuits configuration. Each leaf (e.g.,$u_{l_{i-1}},v_{l_{i-1}}$) initiates a signal on its second pin, which propagates along the red highlighted circuit of segments $s_1$ and $s_2$. At the turning point $tp$ both $s_1$ and $s_2$ segments converge and by the partition sets each signal is processed independently.

Theorems & Definitions (21)

• Lemma 1: Feldmann et al. DBLP:journals/jcb/FeldmannPSD22, Padalkin et al. DBLP:journals/nc/PadalkinSW24
• Lemma 2: Padalkin et al. DBLP:journals/nc/PadalkinSW24
• Lemma 3
• Lemma 4
• Lemma 5
• Lemma 6
• Theorem 7
• Theorem 8
• Corollary 10
• Theorem 11