When a search algorithm expands a state, it produces children that differ from their parent in only a few facts. In the 15-puzzle, one tile moves. In Sokoban, one box shifts. Yet when a learned neural network scores those children (the "heuristic" that tells search which states look promising), it is usually run from scratch on each child, as if the child were an unrelated input. Neuromorphic chips work differently. These processors, such as Intel's Loihi 2, are built from simulated spiking neurons that compute only when an input event arrives. On such a chip the natural way to score a child is to send in only the facts that changed and let the network update its internal state, so that energy scales with how much changed rather than with network size. This note proposes building that delta-driven spiking heuristic and placing it inside a parallel search. Its central argument is that the property parallel search already values for communication reasons, keeping a state and its children on the same processor, also determines how much energy the heuristic burns.
The core claim is that, for search guided by a learned heuristic, the energy cost per evaluated node on a neuromorphic substrate is governed by one measurable quantity. Call it delta-locality: the number of input facts that differ between the state being scored and the state whose activations are already resident on that core. Parallel search partitioning schemes set this quantity directly. Uniform hashing scatters children across cores and destroys it. Abstraction-based partitioning preserves it. If the claim holds, the old trade-off in parallel search between communication overhead and search overhead gains a third axis, evaluation energy, which can be optimized on purpose.
What exists and where this sits
Parallel search has two families of partitioning. Hash-based ownership sends each generated state to an owner processor chosen by a hash, which removes locks. Stefan Blom et al. showed this for distributed breadth-first search. Parallel Beam Search Algorithms for DIDP used it to reach 9× to 39× speedups on 32 threads. Abstraction-based schemes instead group states into coarse blocks so that a state's children usually stay local. Parallel Structured Duplicate Detection (Zhou et al.) expands blocks whose possible-children scopes are disjoint. PBNF (Burns et al.) extends that to best-first search. Abstract Zobrist Hashing (Jinnai et al.) hashes abstract features so that neighbors usually share an owner while load stays balanced. All of this work treats locality as a communication and duplicate-detection issue. None of it considers what locality does to the cost of computing the heuristic, because on CPUs that cost does not depend on which state was scored last. We reuse these partitioning methods unchanged. What is new is measuring and exploiting their effect on evaluation energy.
On the neuromorphic side, the work that motivates us establishes the energy premise. Tang et al. report 15.53 µJ per spiking-policy inference on Loihi versus 1171.70 µJ for a GPU policy on a Jetson TX2. Bal and Sengupta cite 0.9 pJ for an addition versus 4.6 pJ for a multiply-add in 45 nm CMOS. These figures cover arithmetic or whole reactive policies, not search. The closest bridge between the two fields is Solving QUBO on the Loihi 2 Neuromorphic Processor. It maps a combinatorial problem onto synapses and runs parallel simulated annealing at about 2.62 W. That work also constrains our design. It keeps no open list, no duplicate detection, and no bound. Its authors note 8-bit weights and roughly 4,000 variables per chip, and they report weakness on rugged cost landscapes. We therefore do not try to put the search itself on the chip. The host CPU keeps the open and closed lists, exact path costs, and duplicate detection. The chip does only the part it suits, which is event-driven neural evaluation. Finally, Learning to Search and Searching to Learn for Generalization in Planning supplies the search regime. It guides sequential Weighted A* with a relational graph network heuristic and reports 207 average expansions on 10×10 Sokoban, against 3,150 for the classical LAMA planner. That work is sequential and dense-floating-point. We parallelize the search and change how the heuristic is computed.
Research Program
The heuristic network is trained conventionally, for example as in the GSP work cited above. It is then converted to a sigma-delta spiking form, meaning each neuron emits an event only when its activation changes by more than a threshold $\theta$. The first layer is linear in the input facts. If $W$ is the first-layer weight matrix and $\Delta x$ is the sparse change in input facts between the resident state and the new one, the first-layer pre-activation of the new state equals the resident value plus $W\Delta x$, which is exact. In deeper layers, a neuron fires only if its input moved by more than $\theta$, so sparsity propagates through the network. The price is a bounded approximation error that grows with $\theta$.
The energy per evaluation on a core is modeled as
$$E_{\text{eval}} \approx E_0 + e_{\text{syn}} \sum_{\ell} N_\ell(\Delta x, \theta),$$
where $E_0$ is a fixed per-evaluation overhead covering host transfer and static power over the evaluation window, $e_{\text{syn}}$ is the energy per synaptic event, and $N_\ell$ is the number of synaptic events in layer $\ell$. That count grows with $\|\Delta x\|$ because events start only from changed inputs.
The parallel search runs on the host with $k$ workers. Each worker is paired with a group of neurocores holding one copy of the heuristic network, together with that network's resident state. When a worker scores a state, the delta is computed against whatever state its cores last held. Under uniform Zobrist hashing, the resident state is essentially unrelated to the new one. Under PSDD or Abstract Zobrist Hashing, it is usually the parent or a sibling. We also add one cheap host-side change: within a worker's batch, states are sorted so that consecutive evaluations are close in Hamming distance, for example by abstract block and then by parent.
The work has four parts. The first is converting and quantizing heuristic networks to 8-bit sigma-delta form. The second is the host–chip evaluation pipeline. The third is instrumentation that logs the delta size, event count, and measured energy for each evaluation. The fourth is a sweep over partitioning schemes and thresholds, which traces the three-way frontier between search overhead, communication overhead, and evaluation energy. Energy will be measured on Loihi 2 hardware if access is obtained. Otherwise we will use event counts multiplied by published per-operation energies, and we will clearly label those results as modeled, because the 0.9 pJ versus 4.6 pJ comparison covers arithmetic only and leaves out memory traffic.
Baselines
The naive reference point is the same parallel search with the same trained heuristic, evaluated densely from scratch for every node. It runs as int8 batched inference on a CPU and on an embedded GPU, with wall power measured. Every energy number is reported relative to it. This baseline answers whether a neuromorphic chip helps at all.
The strongest existing search method is Hash Distributed Best-First Search with Abstract Zobrist Hashing (Jinnai et al.). It reports an average efficiency of 0.797 and 282.29 s total wall-clock time on 8 threads on IPC planning, against 298.92 s for plain Zobrist hashing. For learned-heuristic guidance we use the GSP configuration of Learning to Search and Searching to Learn for Generalization in Planning, which reports 207 average expansions on 10×10 Sokoban. We run these with identical trained weights, identical instance sets, identical time limits, and the same number of workers. Search parameters are tuned once on held-out instances and frozen. No energy-per-heuristic-evaluation figure for learned search heuristics was found on Lacuna, so that comparison is established here rather than borrowed.
The strongest conventional competitor for energy is an incrementally updated CPU heuristic. On a CPU, the first-layer pre-activation is updated by adding the changed weight columns, while deeper layers are recomputed densely. Game-playing engines use this technique. It is run on a low-power embedded CPU with the same delta-friendly ordering, so that it gets the full benefit of locality.
Two ablations isolate the key ingredients. A spiking network that re-encodes each state in full, with no resident state, separates the delta mechanism from simply moving to neuromorphic hardware. Uniform hashing versus PSDD or AZH partitioning, holding everything else fixed, separates the effect of locality.
Beating the baselines means two things. First, lower energy to solution than both the dense baseline and the incremental CPU baseline at matched coverage. Second, expansions within a small tolerance, roughly 5%, of the dense-heuristic run. That second condition ensures savings do not come from a degraded heuristic.
Why not just…?
Why not just run hash-distributed search on a multicore CPU, which already scales? For wall-clock time it does; Parallel Beam Search Algorithms for DIDP gets up to 39× on 32 threads with a classical evaluation. Our proposal does not compete on speed. It targets the regime where a learned heuristic dominates the cost per node and energy is the constraint, as in edge robotics. The CPU-baseline comparison reports both wall time and joules. If the neuromorphic pipeline wins on joules but loses badly on time, we will report exactly that.
Why not just update the first layer incrementally on a CPU? This is the real threat. If most of the network's work sits in the first layer, an incremental CPU update captures nearly all of the benefit without exotic hardware. The deciding experiment measures how event sparsity decays across layers. If deeper-layer event counts are near dense, the spiking version offers nothing beyond the CPU trick, and we will say so. The proposal pays off only if sigma-delta thresholds keep deeper layers sparse while expansions stay near the dense run. Sparse irregular updates in deep layers are where event-driven hardware has a structural advantage over CPUs.
Why not just quantize the network and batch it on a GPU? Batching amortizes overhead but still computes every child in full, so its cost cannot drop with small deltas. The dense-GPU baseline measures this directly. We expect batching to win when deltas are large, as under uniform hashing or on high-branching domains, and to lose when deltas are small. The crossover point is itself a result.
Why not just use neuromorphic annealing as in Pierro et al.? Solving QUBO on the Loihi 2 Neuromorphic Processor gives no bounds, no duplicate detection, and degrades on rugged landscapes. It also requires the entire problem to fit within roughly 4,000 variables of 8-bit weights. Our design keeps exact systematic search on the host, so these limits do not apply. Only the fixed-size heuristic network has to fit on the chip.
Why not just use a cheap classical heuristic? When a classical heuristic is good enough, evaluation is cheap and this proposal is unnecessary. We include LAMA-style classical search as a reference, at the reported 3,150 expansions on Sokoban, and restrict our claims to domains where learned heuristics reduce total work.
Proposed Experiments
The benchmarks are 10×10 Sokoban with 1,000 test instances, the 15-puzzle, and the 2023 IPC Learning Track domains as used by GSP. For the IPC domains we use Blocksworld at sizes whose relational network fits the chip, reporting the largest size that fits. We also include IPC STRIPS tasks so that the AZH comparison can be made.
The first decisive check tests the core claim directly. Measured energy per evaluation, plotted against the logged delta size, should be close to linear with an intercept $E_0$ that is small relative to the dense cost. If $E_0$, dominated by static power and host transfer, swamps the event term, event-driven evaluation is irrelevant and the project stops there.
The second check is the partitioning ablation. Moving from uniform hashing to AZH should cut mean delta size and energy per evaluation by a large factor. At the same time it should change expansions only by the search-overhead differences that Jinnai et al. already characterize.
The third check sweeps the threshold $\theta$. It traces energy against expansions and coverage, and it identifies the point where approximation error starts inflating search effort.
The fourth check compares energy to solution against the incremental CPU baseline at matched coverage. That comparison decides whether neuromorphic hardware adds anything beyond a clever CPU implementation.
References
- Distributed Analysis with mu CRL: A Compendium of Case Studies
- Parallel Beam Search Algorithms for Domain-Independent Dynamic Programming
- Parallel Structured Duplicate Detection
- Best-First Heuristic Search for Multi-Core Machines
- Abstract Zobrist Hashing: An Efficient Work Distribution Method for Parallel Best-First Search
- Reinforcement co-Learning of Deep and Spiking Neural Networks for Energy-Efficient Mapless Navigation with Neuromorphic Hardware
- SpikingBERT: Distilling BERT to Train Spiking Language Models Using Implicit Differentiation
- Solving QUBO on the Loihi 2 Neuromorphic Processor
- Learning to Search and Searching to Learn for Generalization in Planning