Proximal Targets Enable Looped Refiners to Solve Multi‑Solution Puzzles
Researchers propose proximal targets for looped refinement models, eliminating loss floors caused by multiple correct answers and boosting Sudoku solving rates.
Source: Grafy Research LabLooped refinement models such as the Hierarchical Reasoning Model (HRM) and Tiny Recursive Model (TRM) have shown that a tiny network, applied repeatedly to a draft answer, can solve highly constrained puzzles. The new pre‑print from Syed Affan Daimi (arXiv:2611.22737) demonstrates that the standard training target – a single stored answer per puzzle – creates an irreducible loss floor when a puzzle admits many correct solutions. By replacing that target with a proximal one, the authors remove the floor and achieve near‑perfect solving rates on several benchmark tasks.
Why do standard targets cause blending in multi‑solution puzzles?
Looped refiners are trained with deep supervision: every pass receives a loss that compares the network's output distribution to a target answer. When the dataset stores only one answer for a puzzle that actually has many, the target is essentially independent of the draft the model sees. The authors prove (Lemma 1) that under this independence the loss‑minimising pass outputs the marginal distribution over all correct answers, which in practice looks like a blended grid that satisfies none of the puzzle’s rules. Their experiments on Sudoku with 2–64 possible solutions show the model’s success rate drops from 96 % (unique‑answer puzzles) to just 2.5 %, and scaling the network four‑fold does not improve the result.
What is a proximal target and why does it fix the problem?
A proximal target selects, for each draft, the correct answer that is closest to that draft according to a simple cell‑wise distance . Formally, with a cost function , the target is
where is the set of all valid answers for puzzle . When this reduces to the nearest‑answer rule. Because the target now depends on the draft itself, the loss floor disappears: the optimal pass can simply output the target, and every correct answer becomes a stable fixed point of the loop. The authors verify (Lemmas 2 & 3) that the training loss bounds how many errors a pass must correct, guaranteeing convergence as long as each iteration reduces the error count.
How strong is the empirical evidence?
The paper reports results with a 1.7 M‑parameter network trained over five random seeds. On Sudoku puzzles that have between two and sixty‑four solutions, the proximal‑target model solves 98.8 % of instances, compared with 2.5 % for the standard target. For sparse Sudoku (over 10 000 solutions) the success rate jumps from 0 % to 93.8 %, even though no explicit answer list is provided – the model uses a warm‑started solver to locate the nearest solution. On 200‑node graph‑colouring tasks, the success rate rises from 36.9 % to 90.9 % when training only on graphs up to 50 nodes. The authors also compare against GRAM, a stochastic‑latent reasoner: a single run of the proximal‑target model is correct 98.8 % of the time versus 57.7 % for GRAM, and twenty runs discover more distinct solutions (53.6 % vs 37.4 %). Additional experiments on Scrabble show that a quality‑control “knob” can steer the solver toward higher‑scoring words.
How can creators and researchers try out these ideas with Grafy?
While Grafy does not yet ship a built‑in looped refiner, the research workflow can be reproduced using two of our core apps:
- Grafy Reader – Load the arXiv PDF, ask follow‑up questions, and extract the algorithmic details (e.g., the pseudo‑code in Algorithm 1). This lets you explore the proximal‑target logic without leaving the platform.
- Grafy Chat – Prompt the multi‑model chat to generate a minimal Python implementation of a looped refiner that follows the proximal‑target rule. You can then run the code in a temporary sandbox or export it to Grafy Code for deeper experimentation.
If you already have a small model (e.g., a 1‑M‑parameter transformer) you can use the Code studio to implement the loss function with the proximal target computed on‑the‑fly. The Graph app can help you visualise the training loop: each node represents a pass, its edges show the draft‑to‑target transformation, and you can branch off to test different “knob” settings for quality control.
What are the current limitations and next steps?
The proximal‑target approach still relies on being able to locate the nearest correct answer for each draft. The authors discuss three practical sources for that target: (1) scanning a pre‑computed answer list, (2) invoking a depth‑first search solver started from the draft, and (3) applying a quality‑band knob when answers have a ranking. For domains where no fast solver exists, building such a solver may be the bottleneck. Moreover, the method assumes a well‑defined distance metric ; extending it to continuous‑valued outputs (e.g., image generation) remains an open question. Future work could integrate learned solvers or differentiable search procedures to broaden applicability.
Frequently asked questions
How does the proximal target differ from the standard single‑answer target?
The standard target is fixed for a puzzle, regardless of the current draft, which leads the network to output a probability mixture of all possible answers. The proximal target selects the correct answer that is nearest to the draft, making the target a function of the draft itself and eliminating the mixture effect.
Do I need an exhaustive list of all correct answers to use proximal targets?
Not necessarily. The paper shows three ways to obtain the target: (1) a pre‑computed answer list, (2) a search solver started from the draft (which can discover a nearby answer on the fly), and (3) a quality‑controlled band defined by a knob. The second option works even when the answer space is huge, as demonstrated on sparse Sudoku.
Can I experiment with looped refiners directly inside Grafy?
Grafy does not provide a dedicated looped‑refiner app, but you can prototype the approach using Reader to study the paper, Chat to generate starter code, and Code to run and iterate on a small model. The Graph app is handy for visualising the iterative process and comparing different target‑generation strategies.
Source: https://arxiv.org/abs/2611.22737


