A Perfect Scorer Is Not a Generator

2026-06-05 ~12 min read

An energy-based model that can tell a valid Sudoku grid from an invalid one almost perfectly should, in principle, be able to produce a valid grid: just descend the energy. We trained one from scratch to test exactly that, in the regime where energy-based reasoning is supposed to win. It scored validity beautifully and generated nothing — zero solved puzzles, even after we gave it a perfectly carved landscape and a perfect latent. A recursive refiner with fewer parameters solved roughly fourteen percent. The wall is not the energy. It is finding the point the energy already knows how to score.

Why Sudoku, and why this regime

The appeal of energy-based reasoning is revision. An autoregressive model writes an answer left to right and cannot easily walk back an early commitment when a later token reveals it was wrong. An energy model, in the idealized telling, holds the whole answer at once and slides it downhill toward a low-energy configuration, free to change any part at any time. On problems where the hard part is global consistency rather than local fluency, that should be the better paradigm.

Sudoku-Extreme is a clean place to test the claim. The puzzles are genuinely hard — general-purpose language models solve only a couple of percent — success is exact and unambiguous (a grid is either the unique solution or it is not), and autoregression is structurally weak on it, because filling cells in a fixed order is precisely the thing a constraint puzzle punishes. If energy descent is ever going to beat left-to-right generation, this is the home field.

So we trained three generators from scratch, at matched compute — same parameter budget, steps, data, and batch size — and scored each by held-out exact-grid solve rate, with no partial credit and no constraint checker in the loop to flatter anyone:

An autoregressive transformer over the 81 cells, evaluated greedy and with self-consistency voting. This doubles as the headroom control: if even self-consistency is near-ceiling, the regime is too easy to be informative.
An energy-based model — a network scoring a full candidate grid — decoded by descending its energy in a continuous relaxation of the grid. This is the direct test of the “descend the energy” recipe.
A recursive refiner in the style of recent tiny-recursive-reasoning work: a small network applied repeatedly to revise a full candidate grid, trained end to end with deep supervision. A non-autoregressive generator that is not energy descent.

The headline

Generator (matched compute)	Exact-grid solve	Blank-cell accuracy
Autoregressive, greedy	~0.004	0.35
Autoregressive, self-consistency	~0.003	—
Energy model, argmin decode	0.000	0.11 (chance)
Energy model, energy-descent decode	0.000	0.11 (chance)
Recursive refiner	0.141	0.66

Two things to read off this table before anything else. First, the headroom control passes: the autoregressive model genuinely learns — its blank-cell accuracy of 0.35 is three times the one-in-nine chance rate — yet it solves almost no complete puzzles. That is the honest weak-autoregression regime we wanted, the one where there is real room for a better generator to win. Second, a better generator does win, by a wide margin: the recursive refiner solves about one puzzle in seven, with fewer parameters than the others. Non-autoregressive holistic generation beats left-to-right generation here, exactly as the thesis predicts.

The surprise is the middle two rows. The energy model is the candidate that was supposed to embody the revision advantage, and it solves nothing. Worse than the autoregressive baseline, worse than chance on individual cells. To understand why, you have to separate two things the word “energy model” quietly conflates: scoring an answer and producing one.

The energy is a near-perfect scorer

Trained contrastively — push the energy of the true grid down, push corrupted grids up — the model converged cleanly. The gap between the energy it assigns a correct solution and the energy it assigns a corrupted one is large and stable. Hand it a grid and ask “is this a valid solution to this puzzle,” and it answers correctly almost every time. As a verifier, it works.

Then we asked it to generate, the only way an energy model can: start from a blank (or random) grid and follow the energy downhill, in a continuous relaxation so the gradient is defined, then read off the nearest discrete grid. We tried the two standard decoders — per-cell argmin of the converged relaxation, and continuous gradient/Langevin descent, which is the literal mechanism an energy-based solver uses. Both produced zero solved puzzles, chance-level individual cells, and more constraint violations than a random fill.

Scoring and generating are different problems. A contrastively trained energy carves a deep, narrow basin around the true answers, because that is all the training signal asks of it. It says nothing about the vast space between answers, which is exactly the space a decoder has to traverse to find one. The model learned where the valid grids are. It did not learn a path to them.

We tried to fix the decode three ways

The natural objection is that the energy was simply trained badly for decoding, and a better-shaped landscape would let descent through. We spent three experiments removing that excuse, one variable at a time. This is the part of the work we find most useful, because each fix addresses a real, nameable failure — and the solve rate stays at zero through all of them.

Variant	What changed	Diagnostic
v1	Energy on the raw grid, local (corruption) negatives	Decoded grids sit below the true grid in energy — broad low-energy “flatlands” far from any solution; descent drifts into them.
v2	Global negatives via persistent contrastive divergence, plus an anti-collapse term	The flatlands are carved away: decoded grids now sit above the true grid in energy. But descent still cannot find the basin — no funnel.
v3	Descend in a learned latent that reconstructs solutions perfectly (recon = 1.00)	The target provably exists and decodes exactly; the landscape is carved. Descent still ends at high energy, never reaching the solution.

Read top to bottom, this is an elimination argument. The first failure is that the energy is low in the wrong places; we fixed it, and the flatland diagnostic flipped from “decoded grids are lower energy than the truth” to “decoded grids are higher energy than the truth.” The second failure is that even a correctly carved landscape is a high plateau with a sharp, narrow spike at the answer, and descent from a cold start has no slope to follow toward the spike. We compressed the space into a latent that reconstructs unseen solutions perfectly, so the target is reachable in principle and the representation is not the bottleneck. The solve rate did not move.

Representation was not the wall, and carving was not the wall. With a perfect autoencoder and a perfectly carved energy, descent from a blank start still generates nothing. Whatever is missing, it is not expressiveness and it is not landscape shape. It is the search.

The reversal: proving it was the starting point all along

An elimination argument is suggestive; we wanted a direct one. So we ran a final experiment that holds the energy fixed and changes only where the search begins. We trained the carved energy model and the recursive refiner on the same data, then evaluated four inference procedures against the same two trained models:

Inference procedure	Exact-grid solve
Energy descent from a random start	0.000
Refiner alone (greedy)	0.180
Energy descent from the refiner’s output	0.166
Energy-rerank of 32 refiner samples	0.120

The first and third rows are the same energy and the same descent procedure. The only difference is the starting point. From a random grid, descent solves nothing. From the learned refiner’s output, the very same descent solves about one puzzle in six. A jump from zero to sixteen percent, driven entirely by where the search begins, is the clean statement of the result we had been circling:

The wall is amortized inference, not the energy. Generation needs a learned map that lands you near the answer. The energy can describe the answer and even polish a good starting guess, but it cannot manufacture the starting guess by descent. The refiner works because it learns that map end to end; energy descent fails because it has no map, only a landscape.

The honest negative: the energy did not help the generator

We want to be straight about the rows we did not get to celebrate. The hope going in was a clean “generator plus verifier” story: let the refiner propose, let the energy pick or polish, and beat the refiner alone. That is not what happened. Descent from the refiner’s output (0.166) came in slightly below the refiner by itself (0.180), and letting the energy rerank 32 refiner samples (0.120) was worse still. In this setup, the energy model did not improve the generator. It mildly hurt it.

The reason is consistent with everything above. The energy was trained to separate true grids from globally sampled negatives — gross validity. The refiner’s mistakes are not that; they are near-correct grids, a distribution the energy never saw on the wrong side of its margin. Asked to rank candidates that are all almost right, a validity scorer has little to say, and what it does say is noisy enough to displace the refiner’s own, better-calibrated mode. A perfect coarse scorer is not a good fine-grained selector.

A verifier trained for validity is not automatically a good reranker. The skill of telling valid from invalid is not the skill of telling better from worse among things that are all nearly valid. If you want an energy to rerank a strong generator’s outputs, you likely have to train it on that generator’s own errors as the hard negatives — not on generic corruptions. We did not, and the generic version did not transfer to the reranking job.

What we take from it — and what it says about Kona

The constructive reading is not that energy-based reasoning fails. It is that the load-bearing component is the learned inference map, and the energy’s defensible roles are narrower and more specific than “descend me to get an answer”:

Generation wants a learned amortized map. A recursive refiner — a small network trained end to end to revise a whole candidate — generates where energy descent does not. For us this points squarely at recursive refinement as the generator substrate, not gradient descent on a scorer.
The energy’s job is scoring and supervision. A near-perfect validity scorer is exactly what you want as a training oracle for the generator and as a gross-validity or abstention gate at inference time. It is not, on this evidence, a drop-in rerank or polish stage on top of a strong generator.

This experiment was prompted by a striking public demonstration: an energy-based model from Logical Intelligence (Kona) reported solving Sudoku-Extreme at very high accuracy, and framed the result around descending a learned energy. We want to be careful and charitable here, because we did not run Kona and cannot speak to its internals. What our three-experiment elimination plus the reversal does show is that the naive reading — “train a contrastive energy and gradient-descend it from blank” — fails on this benchmark even with a perfect latent and a perfectly carved landscape. So a high-accuracy energy-based Sudoku solver is, on our evidence, almost certainly doing amortized inference: a learned procedure that produces the trajectory, with the energy as objective and guide, rather than naive descent from nothing. The energy is in the loop. It is not doing the search by itself.

Caveats

These are deliberately small, from-scratch, matched-compute models, and the numbers should be read as a comparison, not as a leaderboard entry. A few specific limits:

Absolute scores are low by design. Our refiner solves about 14 percent; full-scale recursive reasoners report far higher on this benchmark. The ordering — refiner well above autoregression, both far above energy descent at zero — is the result, not the magnitudes.
There is real seed variance. Across three seeds the refiner’s exact-grid solve rate ranged from 0.112 to 0.182 (mean about 0.141), while its per-cell accuracy stayed stable around 0.66. The gap to the other generators is far larger than this spread, but the headline number is a mean over a noisy metric, not a precise constant.
The metric is strict. Solve means all 81 cells exactly match the unique solution. No partial credit.
Our reading of Kona is a reading. We did not run it. The claim we are confident in is about the naive energy-descent recipe we tested, not about any specific other system.

The one-line version: an energy model learned to recognize a correct Sudoku grid almost perfectly and could not produce one by descent, even with every excuse removed; a learned refiner could; and the same energy became useful again the moment it started from the refiner’s guess instead of from nothing. A perfect scorer is not a generator. It is a perfect scorer, which — for a project whose whole thesis is that verification is the scarce, trustworthy primitive — turns out to be exactly the role worth keeping it in.