{"id":"9b03ee32-770c-4aa6-8178-3ba601cfe518","arxiv_id":"2607.19635","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"In clue-rich Sudoku, LDT-style lattice reasoners are one-shot amortized predictors: the first pass fixes the grid, all failures are first-pass poisonings, and search changes efficiency but not accuracy.","lead":"Neural solvers for Sudoku-like puzzles are assumed to reason step by step, but this paper shows that on clue-rich puzzles a single forward pass already fixes almost the whole grid, and later search only removes wasted work. The same diagnosis predicts two fixes—digit shuffling during training and combining shuffled passes at test time—and both raise accuracy to near or at 100%.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Search inertness is measured on a baseline stripped of LDT's per-step augmentation; that augmentation breaks deterministic first-pass poisoning on which the one-shot/inertness conclusion rests, so the central claim may not transfer to the original LDT recipe.","rationale":"The paper's central claim has two layers: (1) the empirical finding that, for the authors' reimplementations, the first pass commits the grid and all failures are first-pass poisoned; (2) the generalization that this is what LDT-like systems do in clue-rich completion, so search is accuracy-inert. The internal measurements are unusually well supported: exact set equalities, replicated contingencies, a clean-room verifier audit, and committed raw artifacts. The load-bearing weak point is the generalization layer. The baseline deliberately omits the original LDT recipe's per-step augmentation, which is precisely the mechanism that would break the deterministic poisoning inheritance on which the search-inertness argument relies. The paper itself flags this in Table 2's footnote, §4, and §5.3, and lists the augmented extended-budget arm as unfinished in the revision protocol. This is not an internal inconsistency; it is an external-validity gap. The reader's conditional verdict already captures this concern, and my more specific version—tying the gap to the deterministic-inheritance mechanism—does not change the verdict. I recommend keeping the verdict UNCHANGED: the conditional acceptance is appropriate until the original-recipe augmentation is tested at adequate budget.","tokens_in":21088,"tokens_out":8514,"duration_ms":95888,"concrete_test":"Run the authors' LDT reimplementation with the original recipe's per-step digit-permutation × dihedral augmentation (not the CoLT parameterization) on the frozen 6×6 data and the Phase-4 9×9/25-clue split, at the recipe's intended budget or 10× the frozen 5k/20k steps. Then repeat the hard-slice anatomy on the augmented checkpoint: for each puzzle, record whether a single forward pass in one unpermuted frame deletes a true-solution value, and compare restart×random vs dfs×learned solved sets exactly. If any clean-first-pass puzzle fails under restart but is solved under dfs, or any first-pass-poisoned puzzle is rescued by later augmented passes, the one-shot/inertness claim fails for the original architecture. If the exact contingency (all failures poisoned, zero clean failures) and exact arm equality reproduce, the claim transfers.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim that in clue-rich regimes LDT-like systems are one-shot predictors whose search only removes waste rests on the hard-slice contingency: every failure is first-pass poisoned (43/43 vs 0/137, replicated) and monotonicity prevents restoration. That argument depends on first-pass poisoning being deterministic and inherited by every chain. But the published LDT recipe includes per-step digit-permutation × dihedral augmentation (omitted from the baseline; Table 2 footnote, §4, §5.3), and §5.3 itself says this mechanism 'de-correlat[es] elimination errors across steps and chains.' Under that augmentation, the first pass is not a single canonical state: a value deleted in one random frame can be kept in another, so later search passes are not condemned to the same poisoned state. H2 (test-time union over symmetry frames) demonstrates exactly this de-poisoning effect without retraining, and it does so outside the search loop; it does not show that the original augmented iterative solver is search-inert. The 2×2 at 6×6 (positional tables + augmentation = 0% at the frozen 5k-step budget) does not close this, because the augmented extended-budget arm is still in the revision protocol, and the 9×9 augmentation result is on CoLT's relational parameterization, not the original architecture. So the measured search inertness may be an artifact of the stripped baseline rather than a property of LDT-like systems as the abstract claims.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper reimplements the Lattice Deduction Transformer (LDT) and introduces CoLT, a CDCL-inspired variant with learned branching, DFS/backtracking, and verified leaf-level nogoods, to test whether search compute is what makes sound lattice reasoners accurate. On clue-rich Sudoku (6x6 standard and hard slices, 9x9 at 25 clues), the authors report that a single forward pass commits essentially all blank cells; all observed hard-slice failures are explained by first-pass poisoning (43/43 vs. 0/137, replicated across seeds and environments); and search-side components are accuracy-inert while cutting wasted wrong-completion derivations by roughly 1,500x. Two symmetry interventions predicted by the diagnosis both work: train-time digit-permutation augmentation raises 9x9 accuracy from at most 0.6% to 96.5 +/- 0.3% on a symmetry-disjoint split, and test-time union over symmetry frames raises hard-slice accuracy from about 76% to 100% without retraining. On from-scratch graph coloring, the one-shot behavior disappears and DFS changes accuracy, mapping the boundary of the claim.","tokens_in":21467,"tokens_out":9230,"duration_ms":91343,"significance":"If the central claim holds for the intended class of systems, this is a valuable mechanistic result: it separates amortized prediction from search in neural reasoners, locates the accuracy ceiling in calibration and symmetry rather than search policy, and gives falsifiable predictions that succeed. The paper is exemplary in reproducibility practice -- frozen protocol, pinned data and raw JSONs, clean-room verifier audit, three-seed replications, and an explicit claim audit. The perfect poisoning contingency and the two successful interventions are strong evidence within the experimental scope. The main significance risk is that the negative result is established on a deliberately stripped baseline (LDT without its published per-step augmentation), so the breadth of the 'LDT-like' conclusion is not yet supported; this is a scope/transfer issue rather than an internal inconsistency.","major_comments":[{"comment":"The central negative result -- search is inert, and failures are decided in the first forward pass -- is measured on a baseline from which the published LDT recipe's per-step digit-permutation × dihedral augmentation has been removed (Table 2 footnote; §4 Baselines). The paper itself identifies that augmentation as a mechanism for de-correlating elimination errors across steps and chains (§5.3). Under per-step augmentation the first pass is not a single canonical state: a value removed in one random frame can be kept in another, so the monotone-lattice 'no restoration' argument does not bind across frames. The H2 test-time-union experiment demonstrates de-poisoning outside the search loop, but it does not show that the original augmented iterative solver is search-inert. The abstract's claim about 'LDT-like systems' therefore overreaches the experiments as reported. Please either run the","section":"§4, §5.3, §5.4 (H2)"},{"comment":"The paper correctly states that class-level generalization can rest only on the 9x9 splits, since the 6x6 domain does not admit a symmetry-disjoint split. But the 9x9 head-to-head compares CoLT-aug (96.5%) against an unaugmented LDT reimplementation (0%); no LDT-with-augmentation arm is reported, even though the published LDT recipe includes exactly this augmentation. Consequently the headline 'digit-permutation augmentation raises 9x9 accuracy from below 1% to 96.5%' is a property of CoLT-aug, not of the LDT family. This is load-bearing because the only clean class-level evidence for the general claim is that 9x9 result. Adding the LDT-with-augmentation cell, or narrowing the generalization claim to the CoLT parameterization, is needed.","section":"§6 and §4 (leakage audit)"},{"comment":"The 2x2 factorial is used to support the claim that the CoLT parameterization is what makes augmentation affordable at the frozen budget and that the interaction is a convergence-speed effect rather than an absolute incompatibility. The decisive cell -- positional tables with augmentation at extended budget -- is not run; the paper states the augmented extended-budget arm 'remains in the revision protocol.' The unaugmented positional-table sweep (16.1% at 3x, 37.2% at 10x steps) does not test the augmented condition, where relabeling is expected to erase exactly the value-specific positional patterns the positional model relies on. Since this cell is one of the preconditions for the 'optimization and sample-efficiency, not capacity' interpretation, it should either be run or the claim should be reported as a hypothesis rather than as an established interaction.","section":"§5.4 (2×2 factorial)"}],"minor_comments":[{"comment":"The term 'LDT-like' is used in the abstract and throughout without a precise definition. Given the augmentation caveat, define it at first use, e.g., 'the lattice-deduction family as reimplemented here, including the variant without the originally published per-step augmentation.'","section":"Abstract and §1"},{"comment":"Table 4 reports identical accuracy (76.1%) for all six arms. §4 says arm equalities are exact set equalities, but the table itself should state whether the solved sets are identical, since the 'search is inert' conclusion depends on this being true puzzle-by-puzzle, not only in aggregate.","section":"Table 4"},{"comment":"The GRAM comparison is clearly scoped by the 10-100x budget starvation, but the subsection heading 'Emission validity of a no-abstention baseline' could be even more explicit that the near-100% wrong-answer rate is a matched-budget artifact, not a property of GRAM as an architecture.","section":"§5.1"},{"comment":"Minor formatting: 'MR V' appears with a spurious space in several places (e.g., Table 1, §5.1). In Table 2, a footnote explaining that the LDT row is a reimplementation rather than the original checkpoint would help readers who do not read §4 first.","section":"Throughout"}],"recommendation":"major_revision","confidential_remarks":"The manuscript is unusually strong in transparency, and the negative results are carefully bounded. My recommendation is driven by the gap between the 'LDT-like systems' scope and the unaugmented-baseline evidence. This is fixable within a revision by either running the augmented LDT arm or narrowing the title and abstract claims. The 2x2 extended-budget cell is less central; if the claims are scoped accordingly, that gap could be left as future work."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"This one deserves a serious look. The core empirical claim — in clue-rich Sudoku, failures are decided before search begins — is supported by a clean, replicated contingency: 43/43 vs. 0/137, with replications across seeds and environments; every failure is first-pass poisoned, no clean failure exists. Monotonicity makes that mechanism sufficient, and the zero in the clean-failure cell is the finding. The two predicted cures both work: digit-permutation augmentation takes 9x9 from ~0% to 96.5% on a symmetry-disjoint split, and test-time union over symmetry frames raises the hard slice to 100% without retraining. The paper ships the artifacts to check this: frozen protocol, pinned data, raw JSONs, clean-room verifier. The 1,497x waste reduction from backtracking and nogoods is a real efficiency result even where accuracy is flat, and the graph-coloring boundary study is a sensible sanity check showing search matters when amortization fails, with Proposition 1 explaining why.\n\nWhat bothers me is the scope of the title and abstract. The 'LDT-like systems are one-shot predictors' claim is tested on a reimplementation with the published LDT augmentation removed. The paper flags this in Section 4 and Table 2, but it matters more than the flag suggests. The original recipe's per-step digit-permutation augmentation is explicitly a mechanism for de-correlating elimination errors across steps and chains. If the first pass is randomized, later search passes are not condemned to the same poisoned state; the paper's own H2 union experiment demonstrates exactly that de-poisoning effect at test time. That does not show the original augmented iterative solver is search-inert — it shows the failure mode is value-specific bias that symmetry can remove outside the search loop. The 2x2 at 6x6 (augmentation + positional tables = 0% at the frozen budget) and the 9x9 augmentation result are on CoLT's relational parameterization, not the original LDT architecture. So the negative result transfers cleanly to this reimplementation and to CoLT; the abstract's claim about LDT-like systems generally is not yet established. A referee should push on this.\n\nOther soft spots are minor: the search-inertness null has only about ±7 pp resolution at n=180, though the exact set equalities and the anatomy help; 6x6 cannot have a symmetry-disjoint split, so class-level generalization rests on the 9x9 results; and the depth-0 target is definitionally the full solution for unique-solution puzzles, which the paper acknowledges. None of these sink the diagnostic contribution. The paper is unusually careful about what is measured and what is inferred, and it honestly reports that the learned policy does not beat MRV where branching matters.\n\nBottom line: anyone working on neural CSP solvers, amortized inference, or learned search should read this. The diagnostic method and the two interventions are worth citing even if you remain skeptical of the broad generalization. It deserves peer review, with one missing arm requested: original LDT recipe with augmentation, at 9x9, measuring whether search still changes accuracy. If that arm comes back flat, the strong claim becomes well-earned.","headline":"A genuinely useful diagnostic result — first-pass poisoning explains clue-rich Sudoku failures — but the 'search inertness' claim is measured on a baseline stripped of LDT's augmentation, so the headline generalization is shakier than the abstract implies.","tokens_in":21914,"tokens_out":2987,"would_cite":true,"duration_ms":31742,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"In clue-rich Sudoku, a neural 'reasoner' is a one-shot predictor: one forward pass commits the whole grid, and every measured failure happens there, before search.","keywords":["one-shot amortization","first-pass poisoning","lattice deduction","verify-or-abstain solver","Sudoku","constraint satisfaction","test-time augmentation","graph coloring"],"falsifier":"Take the hard 14-clue 6x6 slice and, for each puzzle, run one clean forward pass and check whether a true-solution value was deleted. The paper predicts every failed puzzle is poisoned and every clean first pass is solved; a single failed-clean or poisoned-solved puzzle would falsify the contingency.","tokens_in":20993,"feed_emoji":"🧩","tokens_out":7179,"duration_ms":61618,"temperature":0.7,"pith_summary":"The paper tries to establish where a sound neural deduction system's accuracy actually comes from. In clue-rich Sudoku, the answer is the very first forward pass: one pass drives nearly every blank cell to a single candidate, so whether a puzzle is solved is already fixed before the iterative loop branches, backtracks, or checks anything. The mechanism of failure is first-pass poisoning—the pass confidently deleting a value the true solution needs—and since the lattice only ever removes candidates, no later search can restore it; every one of the 43 hard-slice failures, and none of the 137 successes, was poisoned. It follows that adding learned search (branching, backtracking, nogoods) cannot change which clue-rich puzzles get solved, only how much compute is wasted (about 1,500x less). The payoff is that the two fixes the diagnosis predicts work: train-time digit-permutation augmentation lifts 9x9 accuracy from below 1% to 96.5%, and test-time union over digit-permuted passes lifts three checkpoints to 100% with no retraining.","feed_headline":"One pass settles every Sudoku a neural solver solves","feed_subtitle":"On clue-rich puzzles, the first pass decides the answer; search can't undo it, but digit shuffling can.","key_machinery":"The load-bearing machinery is the candidate-set lattice: each cell holds a multi-hot set of still-possible values, deduction only removes values, and conflict is an empty cell. Because removal is monotone, a true-solution value eliminated on the first forward pass can never be restored by any later branch, backtrack, or nogood—making first-pass poisoning sufficient for failure. The paper shows it is also necessary by running one clean forward pass per puzzle and finding that all failures, and only failures, are poisoned. Two named mechanisms carry the argument: the depth-0 'abstraction operator' target, which for a unique-solution puzzle is the complete solution, so a well-fit propagator is","core_discovery":"The central discovery is that a sound lattice deduction transformer, despite appearing to run a deduce-branch-backtrack loop, acts as a one-shot amortized predictor in clue-rich regimes. Measured on the author's reimplementations, one forward pass drives all blank 6x6 test cells to exactly one candidate (singleton rate 1.0; 94–96% on augmented 9x9), turning the iterative solver into an exact verifier around a one-shot guesser. On a harder 14-clue 6x6 slice, the success/failure split is exactly explained by whether the first pass deletes a value the true solution needs: 43 failures were first-pass poisoned, 137 clean successes were not, and no late failures appeared—replicated across seeds an","pith_inferences":["The same union-symmetry recipe should transfer to other clue-rich completion tasks with exact value symmetries (Latin squares, Kakuro, nonograms): the paper's frame-type factorial predicts geometry-only frames help less than value relabeling.","If one-shot amortization is the general behavior of verify-or-abstain recurrent reasoners, then benchmark accuracy comparisons among such systems will keep reporting noise unless they control for first-pass calibration rather than search strength.","A direct architectural continuation suggested by the paper: exact value-permutation equivariance in the network should make the V!-fold augmentation unnecessary; the poisoning data make that prediction testable.","The poisoning contingency offers a cheap diagnostic for any new reasoner: run one clean pass and check whether every failed instance had a true value deleted; if any failure survives a clean first pass, the system is doing something beyond amortization and the paper's negative result does not apply."],"forward_implications":["On clue-rich 6x6 Sudoku at the frozen budget, adding MRV, learned branching, DFS backtracking, and a nogood ban set leaves the exact set of solved puzzles unchanged; it cuts repeated wrong completions by 1,497x.","The accuracy ceiling lives in propagator calibration, not search: lowering the elimination threshold does nothing, while digit-permutation augmentation raises 9x9/25-clue accuracy from 0.2% to 96.5% ± 0.3 over three seeds.","Test-time ensembling over K digit-permuted forward passes with union aggregation removes the failure mode without retraining: three hard-slice checkpoints go from 72.8–78.9% to 100% at K=8; mean aggregation does not, because false eliminations are one-sided.","The diagnosis is regime-bound: on from-scratch graph coloring near the 3-colorability threshold, singleton rate drops to 1.4%, DFS beats restart, and value symmetry makes the depth-0 elimination target all-ones—so there is no signal to amortize.","One multi-size checkpoint transfers the local elimination propagator zero-shot from 4x4/6x6 to 9x9 (precision 0.977 at recall 0.597), but the global conflict and policy heads do not transfer, leaving size-invariant global readouts as an open item."],"fun_headline_variants":["Sudoku solver is one-shot: first pass commits grid","First-pass poisoning decides failures before search starts","Digit shuffling alone lifts Sudoku accuracy to 96%","Test-time symmetry union solves all hard Sudoku puzzles"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The diagnosis rests on the assumption that the author's own unaugmented reimplementation of the LDT recipe behaves like the original architecture; if the original's per-step digit shuffling changes the first-pass commit or poisoning profile, the one-shot/poisoning result may not transfer.","fun_headline_variants_meta":{"raw":{"variants":["Sudoku solver is one-shot: first pass commits grid","First-pass poisoning decides failures before search starts","Digit shuffling alone lifts Sudoku accuracy to 96%","Test-time symmetry union solves all hard Sudoku puzzles"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00034,"raw_usage":{"total_tokens":1776,"prompt_tokens":876,"completion_tokens":900,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":620,"completion_tokens_details":{"reasoning_tokens":836}},"tokens_in":620,"tokens_out":900,"duration_ms":8007,"temperature":1.0,"reasoning_tokens":836,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-01T12:09:07.372166+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take the hard 14-clue 6x6 slice and, for each puzzle, run one clean forward pass and check whether a true-solution value was deleted. The paper predicts every failed puzzle is poisoned and every clean first pass is solved; a single failed-clean or poisoned-solved puzzle would falsify the contingency.","supporting_citations":[],"review_version":1}