Sliding Cubes in Parallel

We study the classic sliding cube model for programmable matter under parallel reconfiguration in three dimensions, providing novel algorithmic and surprising complexity results in addition to generalizing the best known bounds from two to three dimensions. In general, the problem asks for reconfiguration sequences between two connected configurations of $n$ indistinguishable unit cube modules under connectivity constraints; a connected backbone must exist at all times. The makespan of a reconfiguration sequence is the number of parallel moves performed. We show that deciding the existence of such a sequence is NP-hard, even for constant makespan and if the two input configurations have constant-size symmetric difference, solving an open question in [Akitaya et al., ESA 25]. In particular, deciding whether the optimal makespan is 1 or 2 is NP-hard. We also show log-APX-hardness of the problem in sequential and parallel models, strengthening the APX-hardness claim in [Akitaya et al., SWAT 22]. Finally, we outline an asymptotically worst-case optimal input-sensitive algorithm for reconfiguration. The produced sequence has length that depends on the bounding box of the input configurations which, in the worst case, results in a $O(n)$ makespan.

💡 Research Summary

The paper investigates the “Parallel Sliding Cubes” model, a three‑dimensional extension of the classic sliding‑cube framework for programmable matter. In this model, indistinguishable unit‑cube modules occupy cells of the integer lattice ℤ³ and may move by two elementary operations: a slide (translation by one unit along the surface of two adjacent modules) and a convex transition (translation along the surface of a single module across two axes). Moves are executed in discrete, unit‑time steps, and a transformation consists of a sequence of parallel steps where any number of modules may move simultaneously. Crucially, at every step a connected backbone must remain; moving modules are considered “free” only if their removal does not disconnect the configuration. Collisions are forbidden, so modules cannot occupy the same cell, swap positions, or pass through each other during a convex transition.

The decision problem asks: given two connected configurations C₁ and C₂ of n modules and an integer k, does there exist a parallel schedule of at most k transformations that converts C₁ into C₂? The number k is called the makespan.

Complexity Results

1. NP‑hardness for makespan 1 vs. 2 – The authors prove that even when the symmetric difference between the start and target configurations consists of a single module, deciding whether the optimal makespan is 1 or 2 is NP‑complete. The reduction is from Planar Monotone 3‑SAT. Variable gadgets are placed along the x‑axis, with positive literals above the axis and negative literals below. Clause gadgets are thin comb‑like structures attached to the appropriate side of each variable. A single “difference” module must travel from one end of the construction to the other in a single parallel step; this is possible only if a path exists that passes through either the positive or negative side of each variable gadget, thereby encoding a truth assignment. Consequently, the problem remains hard even for constant‑size symmetric difference, ruling out fixed‑parameter tractability with respect to that parameter.

2. Corollary – 2‑approximation hardness – From the above reduction it follows that no polynomial‑time algorithm can guarantee a makespan better than a factor of 2 unless P = NP, even when the symmetric difference is constant.

3. Log‑APX‑hardness – Both the parallel and sequential versions of Sliding Cubes are shown to be log‑APX‑hard via a reduction from Set Cover. The construction introduces two types of modules: immobile modules that never move and mobile modules that can move one at a time (sequential setting). Immobile modules are augmented with long, width‑1 “spike” gadgets; any attempt to slide an immobile module would detach its spike, violating the backbone constraint. Selecting a minimal set of spikes to remove corresponds exactly to selecting a minimum set cover, yielding a Θ(log n) lower bound on approximability unless P = NP.

Algorithmic Contribution – Input‑Sensitive Scheduling
The authors present a constructive algorithm whose makespan depends on geometric properties of the input rather than solely on n. Let B be the minimal axis‑aligned bounding box of the initial configuration. Define A as the area of the projection of the configuration onto the base of B (i.e., the number of occupied cells in the xy‑plane) and h as the height of B. The algorithm builds a scaffolding structure inside B and performs a sweep‑plane compression: at each parallel step, as many free modules as possible are slid toward a target layer while preserving connectivity. This yields a schedule of length O(A + h). In the worst case, A and h can be Θ(n), giving an O(n) makespan, which matches the known lower bound for universal reconfiguration and improves upon prior sequential algorithms that required O(n²) moves.

The algorithm is also in‑place: all intermediate configurations remain within the original bounding box, a property valuable for physical implementations where space is limited.

Related Work and Novelty
Previous work focused on two‑dimensional parallel sliding squares, establishing NP‑completeness for makespan 1/2 but leaving the constant‑difference case open. Sequential three‑dimensional sliding cubes have known O(n²) universal algorithms, but no parallel results existed. This paper fills that gap by (i) defining the three‑dimensional parallel model, (ii) proving strong hardness results that apply even under severe restrictions, and (iii) delivering an asymptotically optimal, input‑sensitive parallel algorithm.

Conclusions and Future Directions
The study demonstrates that minimizing makespan in parallel sliding‑cube reconfiguration is intrinsically hard: exact optimization is NP‑hard, and even logarithmic approximations are impossible unless P = NP. Nevertheless, the proposed O(A + h) schedule provides a practical solution that is optimal in the worst case. Open problems include: (a) whether constant‑factor approximations exist for restricted subclasses, (b) extending the NP‑hardness of constant‑difference makespan to the two‑dimensional parallel model, and (c) implementing the algorithm in distributed robotic systems where modules operate with limited local information.