General Computation using Slidable Tiles with Deterministic Global Forces

TL;DR

<3-5 sentence high-level summary> This paper analyzes the Full-Tilt motion-planning model under a deterministic rotational tilt sequence and proves that it can perform general-purpose computation by simulating space-bounded Turing machines, with one machine step realized per constant number of rotations. It establishes PSPACE-completeness for core reachability tasks—occupancy, vacancy, relocation, and reconfiguration—under such cycles, even in minimally complex tile setups, and shows this power extends to efficient Threshold-Circuit simulation. The authors also provide tape-programming methods and extend the framework to two-tape Turing machines and the Single-Step model, outlining implications for systolic arrays and circuit design. Collectively, the results position rotational Full-Tilt as a versatile, programmable computational substrate with strong complexity-theoretic consequences. The practical impact lies in understanding how global-control tilting can realize universal computation and gate-level circuit emulation in highly constrained physical systems.

Abstract

We study the computational power of the Full-Tilt model of motion planning, where slidable polyominos are moved maximally around a board by way of a sequence of directional ``tilts.'' We focus on the deterministic scenario in which the tilts constitute a repeated clockwise rotation. We show that general-purpose computation is possible within this framework by providing a direct and efficient simulation of space-bounded Turing machines in which one computational step of the machine is simulated per $O(1)$ rotations. We further show that the initial tape of the machine can be programmed by an initial tilt-sequence preceding the rotations. This result immediately implies new PSPACE-completeness results for the well-studied problems of \emph{occupancy} (deciding if a given board location can be occupied by a tile), \emph{vacancy} (deciding if a location can be emptied), \emph{relocation} (deciding if a tile can be moved from one location to another), and \emph{reconfiguration} (can a given board configuration be reconfigured into a second given configuration) that hold even for deterministically repeating tilt cycles such as rotations. All of our PSPACE-completeness results hold even when there is only a single domino in the system beyond singleton tiles. Following, we show that these results work in the Single-Step tilt model for larger constant cycles. We then investigate computational efficiency by showing a modification to implement a two-tape Turing machine in the Full-Tilt model and Systolic Arrays in the Single-Step model. Finally, we show a cyclic implementation for tilt-efficient Threshold Circuits.

Figures (26)

• Figure 1: Full-Tilt example of tiles moved through several tilts.
• Figure 2: A State-Cell construction (a single cell of the tape and the TM state control) with three states (including halt) performing an execution. The process starts with the head-domino entering the State-Cell from the left at the dark red domino at the top of the board. In the same cycle, at the leftmost blue and purple tiles, the inert-singletons enter. One cycle later, at the leftmost green and orange tiles, the active-singletons also enter. The head-domino flows through the Tape gadget reading $1$, State gadget setting $q_0$, Tape gadget writing $1$, then sends the $4$ inert-singletons left in the Send gadget before finally being sent left itself.
• Figure 3: (a) The Tape gadget construction, with labeled regions. (b-c) A read operation performed in the Tape gadget. Observe how the placement of the data-singleton affects where the head-domino exits at the end of the operation.
• Figure 4: (a) The Tape gadget construction with the regions used for write labeled. (b) A write $L1$ operation performed in the Tape gadget. The head-domino moves the data-singleton from 0 to 1, then moves into the Send gadget. It returns and is sent left. (c) A write $R0$ operation performed in the Tape gadget. The head-domino does not interfere with the data-singleton, then is sent right.
• Figure 5: State Labeled. According to the State: $x$, and the Symbol read: $y$, the head-domino is sent left at State$_x$ Read $y$ (details in Figure \ref{['fig:statecomp-interactions']}). Or, if $q_x$ is a halt state, the head-domino is sent into container (details in Figure \ref{['fig:StateHalt']}). Each State$_x$ Read $y$ path leads to Map$_{(x,y)}$ where the state is updated (details in Figure \ref{['fig:stateup']}). The new active-singletons and inert-singletons are sent to the Send gadget, and the head-domino is sent to one of the Tape gadget's write inputs.

Theorems & Definitions (14)

• Theorem 1
• Theorem 2
• proof
• Corollary 1
• proof
• Corollary 2
• proof
• Theorem 3
• Corollary 3
• Corollary 4