Neural path planners are networks that learn to plan routes on a map and can be trained end to end. They inherit a hard speed limit from the algorithm they imitate. Value iteration, the dynamic-programming loop at the heart of these planners, passes "how good is it to be here" one grid cell per step. A route of $H$ moves therefore needs at least $H$ network layers. The field's answer has been to go deeper: thousands of layers, gates, and auxiliary losses. That works, but memory and latency grow with path length. This note proposes a different route out. Use the dilated convolutions of pooling-free vision networks, which skip $2^k$ cells at layer $k$ and keep the map at full resolution. Gate each skip with an obstacle signal that is composed exactly as the dilation doubles, so that a long jump is only allowed when every cell in between is free. The resulting block moves value along any obstacle-free straight segment, of any length, in $\log_2 N$ layers on an $N \times N$ map. The number of outer planning iterations then scales with the number of turns in the optimal route rather than the number of steps.
The two-sentence version: dilated convolutions are dangerous in planning because they jump over walls, but straight-line "is this segment free?" signals compose exactly under doubling, and that composition lets dilated layers jump safely. The result is a planner whose depth is (turns) × (log map size) instead of (path length), and whether that trade pays off is an empirical question about map geometry that we propose to measure directly.
Core Claim
The open tension sits between two literatures. Differentiable planners hit a "depth wall." Value Iteration Networks cast one value-iteration step as a local convolution followed by a max over action channels, so reach grows one cell per layer. What Planning Problems Can A Relational Neural Network Solve? shows that, for relational networks, depth must scale with planning horizon for generalization to hold. One-Shot Multi-Path Planning Using Fully Convolutional Networks states the analogous "diagonal rule" for its pooling-free stack of 3×3 convolutions: at least $N$ layers on an $N \times N$ grid. These papers motivate the work.
Meanwhile, pooling-free vision networks reach large receptive fields cheaply with dilation. MeshNet, in State-of-the-Art Stroke Lesion Segmentation at 1/1000th of Parameters, uses a 1→2→4→8→16→…→1 dilation schedule over full-resolution 256³ volumes with 147,474 parameters. That paper supplies the architectural template.
The same paper also supplies the constraint. Dilated sampling skips cells, and MeshNet already shows boundary errors on thin structures. In a maze, a dilation-2 tap reads the cell on the far side of a one-cell wall as if it were a neighbor, so value leaks through walls. Naively dropping MeshNet into a planner should therefore fail on exactly the maps where long-range planning matters.
Our claim is that this leak can be removed exactly. Let $p(x) \in [0,1]$ be a learned per-cell transmission: discount times traversability, in the spirit of the learned propagation parameter in Value Propagation Networks. Let $\delta$ be one of 8 grid directions. Define $c_r(x,\delta)$ as the product of transmissions along the $r$ cells from $x$ in direction $\delta$, and $M_r(x,\delta)$ as the best value reachable by travelling straight from $x$ along $\delta$ for fewer than $r$ cells. Both quantities obey a doubling recursion in which every operation is a single-tap dilated convolution at dilation $r$, plus a multiply and a max:
$$c_{2r}(x,\delta) = c_r(x,\delta)\, c_r(x+r\delta,\delta), \qquad M_{2r}(x,\delta) = \max\big(M_r(x,\delta),\; c_r(x,\delta)\, M_r(x+r\delta,\delta)\big),$$
with $c_1(x,\delta)=p(x)$ and $M_1(x,\delta)=V(x)$.
After $\lceil \log_2 N\rceil$ such layers, $M$ covers every straight ray on the map. A wall anywhere on the segment zeroes $c$, so no value crosses it. One "outer" planning iteration sets $V \leftarrow \max_\delta$ of the shifted ray-max. With uniform step costs this exactly computes value iteration restricted to straight-line moves of arbitrary length.
The consequence is that $K$ outer iterations propagate value correctly along any route made of at most $K$ straight segments. Depth becomes $K \log_2 N$, where $K$ is the turn count of the best route under 8-direction decomposition, instead of $H$. The block is fully convolutional, preserves resolution, is translation-equivariant, and has linear memory in map area per layer (times 8 directions).
This is what is new relative to the file's closest work. No existing paper uses dilation inside value propagation at all. Gap 3 of the research file identifies the wall-leak problem as unaddressed. The gated recursion above turns that problem from a qualitative worry into an exact algebraic statement.
Research Program
The work has three parts.
Mechanism and theory. We will state and prove the turn-bound: $K$ outer iterations suffice for any route with at most $K$ segments. We will also give the matching negative case. On recursive-backtracker mazes with corridors one or two cells long, $K \approx H$ and the method gains nothing over local value iteration except a $\log N$ cost. This makes the method a geometry-dependent bet, and we will report it as one.
Learning. The transmissions $p$, and optionally a learned reward map, are predicted from the input map or image by a small pooling-free convolutional encoder. Training uses imitation of expert actions, as in the VIN line of work. Because $c$ is a product over up to $N$ cells, gradients through long products can vanish. We will compare a log-space parameterization (sums instead of products) against MVProp-style positive-only propagation.
Hybrid. We will append a few ordinary 3×3 value-iteration steps after each ray block, so the planner can also handle short irregular moves that do not decompose cleanly into straight segments. We will test whether this hybrid dominates both pure forms.
The scientific output is a depth-scaling law. For each method, we will plot success rate against layer budget, broken down by both path length $H$ and turn count $K$ of the test instance. The prediction is that our planner's success is governed by $K \log N$ and the baselines' success by $H$.
Baselines
The naive reference is the original Value Iteration Networks with 3×3 kernels and as many iterations as the memory budget allows. It defines the depth wall. On 100×100 mazes, Scaling Value Iteration Networks to 5000 Layers reports that it "dropped to a 0% success rate once the required steps exceeded 60."
The strongest deep-recurrent competitor is DT-VIN from that same paper. It combines state-dependent softmax-normalized transition kernels, an adaptive highway loss, and 5,000 layers. It reports "88% success rate for paths requiring over 1,200 steps" on 100×100 mazes, 93.26% on its 100×100 Ant Maze, and about 61 GB of training memory (versus about 710 GB for GPPN). We will run DT-VIN on its own mazes with its published depth, and then again at matched depth and matched GPU memory to our planner. Beating it means equal or higher success at a fraction of its depth and memory. Higher success at matched depth alone would not be enough to claim a win.
The strongest constant-depth competitor is the 5-layer Transformer planner of Differentiable Spatial Planning using Transformers. It reports about 95% accuracy on Gibson maps against about 60% for baselines. Its attention memory grows as the fourth power of map side. We will train it on identical data, at the largest map size that fits the shared memory budget. Beating it means matching its accuracy where it fits and continuing to scale beyond that size.
On dense 64×64 mazes, MVProp in Value Propagation Networks reports a 100% win rate. Since that is already ceiling, the comparison there is depth and wall-clock cost, not success rate. On 128×128 random obstacle grids, AVIN in Value Iteration Networks on Multiple Levels of Abstraction reports 88.72% success with 1,167 MB of memory.
All methods get the same training maps, the same expert labels, an equal hyperparameter search budget, and a common memory cap.
Three ablations isolate the key ingredient:
- Ungated dilation. A MeshNet-style symmetric dilation stack used as the planning operator, with $c$ removed. This tests the leak hypothesis.
- Gated, no doubling. Gating applied only at the current dilation, without composing $c$ across levels.
- Dilated CNPP. A CNPP-style feedforward pooling-free network (One-Shot Multi-Path Planning, which reports over 99.5% single-path success on its synthetic maps) given a dilated schedule and trained on heatmaps.
Why not just…?
Why not just stack hundreds or thousands of layers, as DT-VIN does? This works, and DT-VIN's 88% at more than 1,200 steps is the number to respect. Its cost, however, grows with path length in both training memory and inference latency, and What Planning Problems Can A Relational Neural Network Solve? suggests that this is intrinsic to local updates. On long-corridor maps our planner should need far fewer layers. On twisty recursive mazes it may not, and the matched-depth comparison, stratified by turn count, will show where each method wins.
Why not just use bigger kernels, as GPPN and GS-VIN do? Gated Path Planning Networks reaches 99.2% on 15×15 mazes with 11×11 filters. Value Iteration Networks with Gated Summarization Module reaches 74.6% on 64×64 mazes. A larger kernel only multiplies reach per layer by a constant while its cost grows with the square of the kernel width. It also has no mechanism for stopping value at walls other than learning it separately for every offset. We include GPPN at 11×11 under the shared memory cap.
Why not just add dilation to an existing convolutional planner and let training sort out the walls? This is the most serious threat, because it is the simplest version of our idea. If ablation 1 or ablation 3 matches our planner on dense mazes, the exact gating is unnecessary and we will report that. We expect it to fail specifically on maps with one-cell walls separating parallel corridors. We will construct a held-out test set of exactly that type to settle the question.
Why not just use a Transformer, or a classical search algorithm? The Transformer planner's memory grows with the fourth power of map side, so the scaling sweep will show where it stops fitting. Classical search with straight-line jumps is the algorithmic ancestor of our recursion. However, it needs a hand-built map, whereas our block learns transmissions from images and is trained end to end.
Proposed Experiments
We will use five benchmark settings: the 15×15 GPPN mazes, 64×64 mazes, the 100×100 DT-VIN mazes, 128×128 random obstacle grids, and Gibson-derived maps. The metrics are success rate, path length relative to the optimal path, layers used, peak training memory, and inference latency.
The decisive check is the stratified scaling plot. Within a fixed map size, we bin test instances by path length $H$ and turn count $K$ and fit success rate as a function of layer budget. The proposal is confirmed if our planner's failures track $K\log N$ while the baselines' failures track $H$. It is also confirmed if, on Gibson maps and random obstacle grids, our planner matches DT-VIN's success at an order of magnitude fewer layers. It is refuted if the ungated dilation ablation performs as well, or if on Gibson maps $K$ turns out to be close to $H$.
A secondary check pushes map size to 256×256 at fixed memory and asks which methods still train at all.
References
- Value Iteration Networks
- What Planning Problems Can A Relational Neural Network Solve?
- One-Shot Multi-Path Planning Using Fully Convolutional Networks in a Comparison to Other Algorithms
- State-of-the-Art Stroke Lesion Segmentation at 1/1000th of Parameters
- Value Propagation Networks
- Scaling Value Iteration Networks to 5000 Layers for Extreme Long-Term Planning
- Differentiable Spatial Planning using Transformers
- Value Iteration Networks on Multiple Levels of Abstraction
- Gated Path Planning Networks
- Value Iteration Networks With Gated Summarization Module