---
title: 'Push-1: Minimal Block-Pushing Motion Planning'
url: https://www.emergentmind.com/topics/push-1
type: topic
---

# Push-1: Minimal Block-Pushing Motion Planning

Push-1 is a block-pushing motion-planning problem on a rectangular grid of unit cells. In the form studied in the complexity literature, each cell is either empty or contains a movable \(1\times 1\) block, and a single \(1\times 1\) robot occupies an empty cell. The robot moves orthogonally through empty cells; if it attempts to enter a cell occupied by a block, the move is allowed only when the next cell in the same direction is empty, in which case the robot and that single block both move one cell. Pulling is disallowed, and the decision problem is reachability: given a start cell and a target cell, determine whether the robot can reach the target. The model was introduced in 1999, shown NP-hard in 2D in 2000, and its fixed-block-free version was proved PSPACE-complete in 2025 [0007021] [2508.19759].

## 1. Model and basic variants

Push-1 is defined by three constraints that distinguish it from nearby block-pushing models: only pushing is allowed, the robot may push at most one block at a time, and a push moves that block by the minimal extent, namely one square. The 2000 formulation places unit square blocks on an integer lattice and assumes that all blocks are movable [0007021].

In the later fixed-block-free formulation, the input is an \(m\times n\) rectangular grid. Each cell is empty or occupied by a movable \(1\times 1\) block, and the robot occupies one empty cell. The robot moves orthogonally through empty cells. If it attempts to move into an occupied cell, the move is permitted only if the next cell in the same direction is empty; then the robot and that single block each move one cell. The only immovable boundary is the rectangular board itself [2508.19759].

The standard comparison points are PushPush and Push-1F. PushPush also permits only one-block pushes, but when a block is pushed it slides the maximal extent of its free range. Push-1F keeps the one-block, one-square rule but adds fixed blocks.

| Variant | Push rule | Status stated in the cited sources |
|---|---|---|
| Push-1 | Push one block one square | NP-hard in 2D; later PSPACE-complete |
| PushPush | Push one block; block slides maximal free range | NP-hard in 2D |
| Push-1F | Push-1 with fixed blocks | PSPACE-complete in prior work |

This taxonomy matters because the computational behavior is sensitive to seemingly small rule changes. In particular, the absence of fixed blocks in plain Push-1 was not a cosmetic difference; it was the reason the original complexity classification remained unsettled for decades [0007021] [2508.19759].

## 2. Early development and the 2D NP-hardness result

The foundational complexity result is the paper "PushPush and Push-1 are NP-hard in 2D" [0007021]. It proves that both PushPush and Push-1 are intractable already in two dimensions. For Push-1, the paper considers the minimal-motion rule: the agent can push only one block one square at a time. For PushPush, the pushed block slides as far as possible.

The 2000 result was significant for two separate reasons. First, it improved an earlier intractability result for a PushPush-inspired puzzle that had been established in 3D. Second, it answered a question previously raised for the Push-1 variant itself. Both hardness proofs are by reduction from SAT and rely on a common construction [0007021].

The 2D setting is essential in the historical interpretation. A 3D hardness construction does not automatically transfer to 2D, because planar routing, crossover simulation, and local blockage behavior become much more constrained. The 2000 paper therefore established that even the geometrically simpler two-dimensional versions already support NP-hard behavior [0007021].

A recurrent misconception is to read the 2000 theorem as settling the full complexity of Push-1. It did not. NP-hardness establishes lower-bound intractability, but it leaves open whether the problem belongs to NP, to PSPACE, or to some larger class. That gap remained open for the fixed-block-free model for roughly a quarter century.

## 3. The pre-2025 landscape and the fixed-block issue

Before 2025, Push-1 and Push-1F were both known NP-hard, and many related pushing and pulling models had PSPACE-hardness or PSPACE-completeness results. In particular, Push-1F—the variant with fixed blocks—had a previous PSPACE-completeness proof. Yet the original Push-1 model, with no fixed blocks, remained unresolved for 24 years [2508.19759].

The obstruction was not merely technical convenience. The later literature emphasizes that the prior Push-1F proof does not adapt to Push-1, because its gadgets crucially used fixed walls. A tempting workaround is to replace a fixed wall by an effectively immobile \(2\times 2\) cluster of movable blocks, since no block in such a cluster can be pushed. However, the 2025 fixed-block-free proof explicitly notes that merely “thickening” the old walls in this way does not preserve the required gadget behavior [2508.19759].

This distinction clarifies the status of Push-1 as a separate subject rather than a minor corollary of Push-1F. The fixed-block-free version asks whether PSPACE-hardness can be realized using only the movable blocks of the original model, together with the implicit outer boundary of the board. The answer turned out to be yes, but only after new reduction routes and new gadget frameworks were developed [2508.19759].

## 4. PSPACE-completeness without fixed blocks

A 2025 proof establishes the exact complexity theorem
\[
\textbf{Theorem. }\text{Push-1 is PSPACE-complete.}
\]
for the fixed-block-free model on a finite rectangular grid [2508.19759].

Membership in PSPACE is straightforward. A Push-1 instance has polynomially many cells; each cell is empty, occupied by a block, or occupied by the robot; and each configuration can therefore be stored in polynomial space. The configuration graph is finite, though exponential in size, so polynomial-space graph search yields \( \mathrm{Push\text{-}1}\in\mathrm{PSPACE} \) [2508.19759].

The PSPACE-hardness proof uses a different route from the earlier fixed-block proof. Rather than relying on door gadgets with rigid walls, it reduces from planar Nondeterministic Constraint Logic and, more generally, from the Graph Orientation Reconfiguration Problem. The paper summarizes the proof chain as
\[
\text{planar NCL} \;\to\; \text{planar targeted set reconfiguration on postselected GORP gizmos} \;\to\; \text{planar reachability with unpostselected gizmos + checking gadgets} \;\to\; \text{Push-1}.
\]
The key methodological device is the framework of strict checkable gizmos, which supports genuine reconfiguration gadgets together with a global final checking phase [2508.19759].

The required Push-1 gadget library includes an AND gizmo, an OR gizmo, a crossover gizmo, and auxiliary checking gadgets such as single-use opening and single-use closing. The AND gadget implements the upward closure of \(\{\{a,b\},\{c\}\}\); the OR gadget implements the upward closure of \(\{\{a\},\{b\},\{c\}\}\); and the crossover corresponds to a wire/crossover with always-traversable token-routing through \(x\leftrightarrow y\). The constructions are designed so that, in normal operation, only a small number of internal blocks move on controlled tracks, while a final checking sequence certifies that no forbidden state was entered [2508.19759].

The absence of fixed blocks is handled in two ways. Some local structures, such as \(2\times 2\) clusters, act like fixed obstacles because no constituent block can be pushed. More importantly, the new gadgets do not rely on pervasive fixed-wall corridor logic. Instead, they use controlled tracks, a small number of relevant movable blocks, and postselection via a final checking phase. In this sense, fixed blocks are shown not to be necessary for PSPACE-hardness in the basic Push-1 model [2508.19759].

## 5. Alternative gadget-theoretic formulation and formal verification

A second 2025 proof also establishes
\[
\textbf{Push-1 is PSPACE-complete,}
\]
but does so through a different high-level route centered on self-closing doors and formal gadget verification [2508.17602].

This work extends the standard motion-planning-through-gadgets framework by assigning the agent an internal state. In the extended formalism, a gadget transition has the form
\[
(q,l,s)\to(q',l',s'),
\]
so a traversal can change not only the gadget state and the port location but also the agent’s own state. For Push-1, this makes it possible to encode whether the agent is merely moving or is currently pushing a block across gadget boundaries [2508.17602].

The same paper introduces GADGETEER, a system for automated verification and synthesis of gadgets. The central formal notion is observational equivalence between a low-level construction and a high-level gadget specification: the two are required to have the same language of observable transition sequences at their ports. GADGETEER computes reachable low-level states, extracts observable behavior, synthesizes a deterministic gadget abstraction, and verifies that the abstraction matches the claimed specification [2508.17602].

The proof strategy is to build and verify a sequence of gadgets, including dicrumblers, single-use opening and closing gadgets, ejectors, hallway cutoffs, a closing crossover, a checkable diode, a checkable 1-toggle, and a precursor. These are then composed into a self-closing door. The final hardness step invokes the known theorem that deciding reachability in a planar system of self-closing doors is PSPACE-complete [2508.17602].

This approach also sharpens the role of checkability. A gadget may have physically possible but unintended “broken” behaviors; however, a global checking path is arranged so that any successful overall solution must leave every gadget in a checkable state. Post-selection on successful checking therefore removes unwanted branches from the effective high-level semantics [2508.17602].

## 6. Significance, methodology, and remaining open directions

Push-1 now occupies a precise place in the complexity theory of motion planning. The 2000 result established 2D NP-hardness; the 2025 results establish PSPACE-completeness for the original fixed-block-free model. A plausible implication is that Push-1 should be regarded as one of the canonical minimal block-pushing models whose apparent simplicity conceals full reconfiguration hardness [0007021] [2508.19759].

The methodological impact is broader than the classification itself. One 2025 line of work builds a bridge between agent-based gadget motion planning and graph-orientation reconfiguration through GORP gizmos, strict checking, and postselection. The other develops explicit agent-state gadget semantics together with machine-checked observational equivalence via GADGETEER. Both directions suggest that the technical bottleneck in motion-planning complexity has shifted from inventing isolated gadgets to designing compositional frameworks that can certify gadget behavior at scale [2508.19759] [2508.17602].

Several caveats remain important. The fixed-block-free PSPACE-completeness theorem is for Push-1 reachability on a finite rectangular grid with only pushing and no fixed blocks. It does not resolve Push-\(*\) without fixed blocks, which is explicitly highlighted as still open. It also does not mean that every local Push-1 gadget is intrinsically irreversible or rigid; many of the crucial constructions are only valid after a final checking phase rules out broken states [2508.19759].

In that sense, the modern theory of Push-1 combines two layers. At the semantic level, it is a reachability problem for a robot that pushes at most one movable block by one square. At the proof-theoretic level, it is a test case for how far planar gadget reductions, postselected checking, reconfiguration frameworks, and automated verification can be pushed in a model with no fixed obstacles and minimal local actuation.

Source: https://www.emergentmind.com/topics/push-1