Recurrent Diffusion Model Hits 99.9% Sudoku Accuracy Without Timesteps

Xiaol.x

Isolating reasoning within an uncorrupted recurrent latent enables models to solve complex puzzles under continuous maximal noise injection without step counters or external verifiers.

AI-assisted summary of How AI Solves Sudoku Through Noise: The Hidden State That Learns to Reason — original source. Check the original for full context.

Source published: 2026-09-07

Key ideas

A new framework (arXiv:2609.01449) equips a diffusion denoiser with persistent recurrent memory but no timestep or iteration counter, achieving a 99.9% exact solve rate on Sudoku Extreme at 10,000 steps and 98.93% on Maze Unique in 100 steps. (0:00)
Rather than annealing noise at test time, continuously injecting maximal Gaussian noise at every single inference step enables single-trajectory exploration, locking 99.24% of converged trajectories onto the correct solution. (4:14)
Mid-inference causal interventions reveal the observable board is disposable: resetting the noisy board while keeping the hidden state raises solve rates from 82.5% to 88.09%, whereas resetting the hidden state drops accuracy to 58.03%. (5:18)
The hidden state receives zero direct supervision, developing purely as an indirect learner through four-step truncated backpropagation across an annealed diffusion training curriculum. (3:00)

Detailed notes

## Background Published on YouTube by Xiaol.x on September 7, 2026, this video breaks down arXiv:2609.01449, 'Diffusion as a Training Curriculum for Timestep-Free Iterative Reasoning,' through a two-host podcast format. The presentation explains how equipping a diffusion denoiser with persistent recurrent memory enables it to solve complex reasoning benchmarks like Sudoku and mazes without timesteps, iteration counters, or external verifiers.

## TL;DR The episode analyzes a recurrent architecture where a diffusion denoiser operates without explicit timesteps or counters, decoupling noisy observable states from an uncorrupted internal memory latent. By passing representations through a shared transformer block that forks into a normalized hidden state and an observable prediction, the network accumulates reasoning across iterations without suffering from drift. Trained via truncated backpropagation on an annealed curriculum, the system can solve puzzles even when unknown cells are wiped with maximal Gaussian noise at every inference step, achieving a 99.9% exact solve rate on Sudoku Extreme at 10,000 steps. Surgical interventions confirm that the hidden state acts as a spatially structured logical notebook rather than a simple clock, establishing that recurrence powers the reasoning while diffusion serves as the curriculum.

## Atmosphere & style The video adopts an intellectually engaging, podcast-style dialogue where co-hosts unpack counterintuitive technical paradoxes with infectious curiosity. Mara and her co-host anchor the dense architectural formulas and ablation metrics in vivid conceptual analogies, such as contrasting a malfunctioning sensor with a clean notebook. The pacing moves smoothly from mechanical breakdowns to empirical post-mortems, giving the listener the sensation of sitting in on a rigorous yet accessible research lab debrief.

## Bulletin - [00:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=0s) A new framework (arXiv:2609.01449) equips a diffusion denoiser with persistent recurrent memory but no timestep or iteration counter, achieving a 99.9% exact solve rate on Sudoku Extreme at 10,000 steps and 98.93% on Maze Unique in 100 steps. - [04:14](https://www.youtube.com/watch?v=d1xVxxPTwus&t=254s) Rather than annealing noise at test time, continuously injecting maximal Gaussian noise at every single inference step enables single-trajectory exploration, locking 99.24% of converged trajectories onto the correct solution. - [05:18](https://www.youtube.com/watch?v=d1xVxxPTwus&t=318s) Mid-inference causal interventions reveal the observable board is disposable: resetting the noisy board while keeping the hidden state raises solve rates from 82.5% to 88.09%, whereas resetting the hidden state drops accuracy to 58.03%. - [03:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=180s) The hidden state receives zero direct supervision, developing purely as an indirect learner through four-step truncated backpropagation across an annealed diffusion training curriculum.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=0s) The model operates as an 'anytime solver' with no clock, timestep index, or iteration counter, determining progress strictly from the corrupted board, fixed clues, and previous latent memory. - [00:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=0s) Reasoning scales continuously with recurrent compute depth instead of drifting or plateauing, reaching a 99.9% solve rate on Sudoku Extreme given 10,000 steps. - [00:54](https://www.youtube.com/watch?v=d1xVxxPTwus&t=54s) Fixed clue pinning isolates immutable puzzle constraints from corrupted guesses, ensuring original givens never degrade while allowing the observable board to fluctuate. - [00:54](https://www.youtube.com/watch?v=d1xVxxPTwus&t=54s) A dual-branch recurrent backbone splits the processed latent into an uncorrupted memory update via LayerNorm and a visible board guess via a linear output map. - [00:54](https://www.youtube.com/watch?v=d1xVxxPTwus&t=54s) The recurrent framework generalizes across domains by swapping the relational self-attention used for Sudoku with local convolutional cellular-automaton blocks for maze solving. - [03:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=180s) Truncated backpropagation through time over four steps updates memory indirectly, as loss is applied exclusively to output predictions rather than the hidden state. - [03:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=180s) Diffusion functions fundamentally as a structured training curriculum rather than an inference schedule; removing noise during training causes complete model collapse. - [04:14](https://www.youtube.com/watch?v=d1xVxxPTwus&t=254s) Forcing maximal noise at every inference step enables a single trajectory to explore alternative hypotheses without needing external rule verifiers or parallel beam search. - [04:14](https://www.youtube.com/watch?v=d1xVxxPTwus&t=254s) Eliminating inference noise causes accuracy to drop to 49.39%, demonstrating that continuous stochastic injection is required to prevent the model from getting stuck. - [05:18](https://www.youtube.com/watch?v=d1xVxxPTwus&t=318s) Causal ablations prove the hidden memory is not an abstract step counter, as spatially shuffling memory vectors degrades solve rates to 29.38% and global shuffling collapses performance to 0.27%. - [06:23](https://www.youtube.com/watch?v=d1xVxxPTwus&t=383s) The core mental model frames the architecture as a noisy sensor paired with a clean notebook: diffusion provides the curriculum, while recurrence carries the reasoning. - [06:23](https://www.youtube.com/watch?v=d1xVxxPTwus&t=383s) Visual trajectories show candidate cell assignments dynamically flipping between correct and incorrect states across iterations as the persistent notebook progressively resolves the puzzle.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=0s) A Timestep-Free Denoiser with Persistent Memory

The episode opens by introducing a deceptively simple question explored in arXiv:2609.01449: what happens if a diffusion denoiser is given a persistent memory but stripped of any clock, timestep index, or iteration counter? The co-host immediately points out the seeming paradox—without a diffusion timestep $t$ or an iteration index, the neural network has no explicit way of knowing whether it is executing step 1 or step 100. The answer is that the network simply does not know. At any given iteration, it only observes three things: a corrupted puzzle state, a set of fixed clue cells, and a hidden latent tensor carried over from the immediately preceding step.

The practical consequence of this design is an "anytime solver" whose reasoning capabilities scale directly with recurrent depth. Rather than degrading or drifting when pushed past its initial horizon, more inference steps consistently improve the accuracy of the answer. The hosts highlight the paper's benchmark numbers to illustrate just how potent this mechanism is: on the benchmark dataset Sudoku Extreme, the model achieves a 99.9% exact solve rate when given 10,000 inference steps. On Maze Unique, it achieves a 98.93% solve rate in 100 steps. As Mara emphasizes, the headline story here is not generating visually appealing images; it is about computation accumulating steadily in a latent space where noise cannot wipe it out: "computation accumulating somewhere the noise cannot erase."

- **Core premise**: A diffusion denoiser operating with persistent recurrent memory ($h_k$) but zero awareness of time, step count, or iteration index. - **Sudoku Extreme performance**: Reaches 99.9% exact solve rate at 10,000 inference steps. - **Maze Unique performance**: Achieves 98.93% exact solve rate at 100 inference steps.

---

[00:54](https://www.youtube.com/watch?v=d1xVxxPTwus&t=54s) Pinned Givens and the Two-Stream Architecture

To explain how the system isolates reasoning from corruption, the hosts dissect the observable board state. In a Sudoku instance, the board consists of fixed clue cells (givens) and unknown cells. The clues remain permanently pinned, while only the unknown cells undergo corruption. This means the observable board $x_k$ at step $k$ is never the final ground truth; it is merely a noisy, fluctuating guess. Under the paper's variance-preserving diffusion path, unknown cells at $t=0$ are maximally corrupted with Gaussian noise, whereas at $t=1$ they represent the clean target. Through an explicit pinning operation, the fixed clue embeddings are copied directly back into every corrupted board, guaranteeing that the original givens never drift or degrade. This decouples the representation into two distinct information streams: the observable board can be overwritten at will, while the underlying puzzle geometry and clue identities remain immutably accessible.

```mermaid flowchart TD accTitle: Recurrent Diffusion Block Architecture accDescr: Diagram showing how pinned noisy board and hidden state pass through shared transformer blocks to produce both updated memory and the current prediction.

subgraph Inputs ["Input Processing"] X["Pinned Noisy Board xₖ"] --> EMB["Embed Eₓ + Pos + Clues"] H_IN["Previous Memory hₖ"] --> ADD["Feature Summation"] EMB --> ADD end

subgraph Core ["Recurrent Backbone"] ADD --> TRANS["Shared Transformer B_θ (8 Inner Passes)"] TRANS --> Z["Final Latent zₖ"] end

subgraph Outputs ["Dual Output Branches"] Z --> LN["LayerNorm(zₖ)"] Z --> LIN["Linear Output Map Eₒ"] LN --> H_OUT["Next Memory hₖ₊₁"] LIN --> Y_HAT["Denoised Guess ŷₖ"] end ```

The underlying network architecture processes these streams through an iterative loop. First, the pinned noisy board is embedded via an input mapping $E_x$, combined with learned positional features and a binary clue flag. The previous hidden state $h_k$ is then added directly to this representation. Crucially, $h_k$ is neither sampled from diffusion noise nor copied from any clean label; it is an internal construct generated entirely by the model itself. The merged features pass through a shared pre-norm transformer block $B_\theta$ applied across eight inner recurrent passes to produce a final latent tensor $z_k$. At that point, the latent splits into two separately normalized functional pathways:

1. **Persistent memory ($h_{k+1}$)**: Formed as $h_{k+1} = \text{LayerNorm}(z_k)$, this branch carries the refined reasoning state forward into the next recurrent step without fresh corruption. 2. **Current prediction ($\hat{y}_k$)**: Processed through a linear output map $E_o$, this branch emits the current denoised board guess.

The hosts note the architectural elegance: "Same computation, two destinations. Memory for future reasoning, prediction for the current visible answer." While Sudoku uses relational self-attention masks along rows, columns, and $3 \times 3$ boxes to model constraints, the exact same recurrent interface transfers to maze solving simply by swapping the attention module for a local convolutional cellular-automaton-style block.

---

[03:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=180s) Training Curriculum via Truncated Recurrence

The discussion turns to the training mechanism, which bridges diffusion noise schedules and recurrent backpropagation. Rollouts are sampled with variable trajectory lengths between 20 and 160 steps, but gradients are not backpropagated through the entire sequence. Instead, the model uses truncated backpropagation through time (BPTT), allowing gradients to flow through only four consecutive denoising steps. At each four-step boundary, the computation graph is detached, but the numerical hidden state $h_k$ survives intact across the boundary. The subsequent segment picks up that exact memory vector and pairs it with a newly sampled corruption of the clean target.

Because the loss function is an unweighted masked mean squared error applied exclusively to the prediction branch $\hat{y}_k$ over those four steps, there is zero direct supervision or loss applied to $h_k$. This turns the hidden state into an "indirect learner": gradient descent only updates the memory pathway if storing information there genuinely enhances the model's future prediction accuracy. Furthermore, training relies on an annealed corruption curriculum that starts with heavily corrupted states and gradually introduces cleaner targets. The hosts review the ablation studies demonstrating why this curriculum is indispensable:

- **Fixed noise training**: Training with fixed noise levels degrades the solve rate to approximately 82.73%. - **Zero noise training**: Completely removing noise corruption during training causes the model to collapse to a 0% solve rate in the reported setup. - **The primary role of diffusion**: As the hosts summarize, diffusion's critical contribution is serving as an ordered training curriculum rather than dictating the inference sampler.

---

[04:14](https://www.youtube.com/watch?v=d1xVxxPTwus&t=254s) Inference with Maximal Noise and Single-Trajectory Exploration

At test time, the standard execution starts with the hidden memory initialized to zeros ($h_0 = 0$) and all unknown cells initialized to pure Gaussian noise. But the authors introduced a profoundly counterintuitive modification: fixing the inference noise level permanently at $t=0$. This means that on every single inference step, every unknown cell is forcibly wiped and replaced with fresh, maximal Gaussian noise.

The hosts marvel at the resulting dynamic. The visible board is completely memoryless, forced into constant amnesia, yet the hidden state remains untouched by the corruption: "The visible board keeps forgetting. The hidden state does not. Noise explores alternatives in $X$. Memory carries structured progress in $H$." This separation allows a single rollout trajectory to simultaneously explore hypotheses and settle toward the solution without requiring parallel beam searches, candidate selectors, or external rule verifiers. Over repeated steps, the decoded Sudoku stabilizes even under constant noise injection:

- **Convergence stability**: 99.24% of trajectories remain locked on the unique correct solution once converged under maximal noise forcing. - **Ablation with zero noise**: When inference noise is completely eliminated, performance drops dramatically to 49.39%, proving that persistent stochastic noise performs active, necessary exploration.

---

[05:18](https://www.youtube.com/watch?v=d1xVxxPTwus&t=318s) Intervention Experiments and the Mechanics of the Hidden State

To verify what kind of information the hidden tensor actually maintains, the authors performed causal surgical interventions midway through inference—specifically at step 200 of a 400-step rollout:

These empirical results settle what the memory actually does: it is not a generic counter or timing device, but a spatially organized, instance-specific representation of where that exact puzzle stands in its logical resolution. Memory capacity also directly governs problem-solving performance: scaling the hidden state width from 64 channels to 256 channels yields consistent accuracy improvements across all evaluated recurrent compute budgets.

---

[06:23](https://www.youtube.com/watch?v=d1xVxxPTwus&t=383s) Code Boundaries, the Mental Model, and Visual Convergence

The conversation touches on reproducibility and the paper's implementation details. While the arXiv publication provides precise algorithmic pseudocode and full architectural specifications, it does not link to an official open-source code repository. Nonetheless, the hosts note that the algorithmic contract is clear and reproducible: pin the clue cells, embed the board and previous hidden state, loop the shared transformer or convolutional block eight times, split the latent into normalized memory and output prediction, and train with four-step truncated backpropagation. The only major difference across domains is communication topology: Sudoku relies on relational self-attention across rows, columns, and blocks, whereas maze solving relies on local cellular-automaton-style convolutions.

Mara and her co-host articulate the clean mental model of the system: > "The clean mental model is a noisy sensor plus a clean notebook. The sensor is $x_k$. The notebook is $h_k$. The denoiser reads both, writes a prediction, and updates the notebook."

Training requires an annealed noise schedule to teach the notebook what logical progress looks like, but once trained, the model can discard the clock and operate under continuous sensor noise. The motto of the paper brings it together: "Diffusion supplies the curriculum. Recurrence supplies the reasoning."

The walkthrough concludes by examining the paper's visual filmstrip of a Sudoku solve. Progress is not an instantaneous, single-pass completion; rather, at steps 0, 3, 5, 8, and 10, candidate cells continuously flip between correct and incorrect assignments (turning green or red) as the recurrent trajectory refines its hypothesis. The observable prediction is allowed to make mistakes because the hidden notebook preserves the underlying work. Quantitatively, this explains why memory-equipped models exhibit an upward-climbing accuracy curve that approaches 100% as step count $k$ increases, whereas memoryless diffusion baselines plateau prematurely.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=d1xVxxPTwus&t=0s) computation accumulating somewhere the noise cannot erase. — Mara

> [00:54](https://www.youtube.com/watch?v=d1xVxxPTwus&t=54s) Same computation, two destinations. Memory for future reasoning, prediction for the current visible answer.

> [04:14](https://www.youtube.com/watch?v=d1xVxxPTwus&t=254s) The visible board keeps forgetting. The hidden state does not. Noise explores alternatives in X. Memory carries structured progress in H.

> [06:23](https://www.youtube.com/watch?v=d1xVxxPTwus&t=383s) The clean mental model is a noisy sensor plus a clean notebook. The sensor is xₖ. The notebook is hₖ. The denoiser reads both, writes a prediction, and updates the notebook. — Mara

> [06:23](https://www.youtube.com/watch?v=d1xVxxPTwus&t=383s) Diffusion supplies the curriculum. Recurrence supplies the reasoning.

## Mentioned arXiv:2609.01449, Sudoku Extreme, Maze Unique, Diffusion as a Training Curriculum for Timestep-Free Iterative Reasoning, Xiaol.x, Mara

## Video description What happens when a diffusion model gets a persistent memory but no timestep, no iteration counter, and no external verifier?

This video explains arXiv:2609.01449, Diffusion as a Training Curriculum for Timestep-Free Iterative Reasoning, through a two-host podcast-style lesson.

We follow the paper’s actual Sudoku results and show:

- How the noisy observable state xₖ changes at every step. - Where the persistent hidden state hₖ comes from. - Why hₖ₊₁ = LayerNorm(zₖ) becomes the model’s clean memory. - How the same latent produces both memory and the current prediction. - Why training needs annealed noise as a curriculum. - Why inference can use fresh maximal noise at every step. - How memory-enabled models continue solving as recurrent depth increases. - Why removing or shuffling the hidden state destroys performance. - How the method transfers from Sudoku to maze solving. - What the paper’s implementation specification says, and what remains unpublished.

The central idea is simple:

Diffusion supplies the training curriculum. Recurrence carries the reasoning.

Paper: https://arxiv.org/abs/2609.01449

Chapters:

00:00 A denoiser that keeps thinking 00:52 The observable puzzle state 02:02 Where the hidden state comes from 03:25 Training the memory indirectly 05:05 Inference with maximal noise 06:40 Interventions reveal what memory stores 08:00 Watching Sudoku get solved 09:20 Final mental model and code boundary

[Source](https://www.youtube.com/watch?v=d1xVxxPTwus)

中文简报

无时间步循环扩散模型数独求解准确率达99.9% 将推理隔离在未受损的循环隐变量中，使模型无需步数计数器或外部验证器，即可在持续注入最大噪声的情况下解决复杂谜题。本期内容分析了一种循环架构，其中的扩散去噪器在没有显式时间步或计数器的情况下运行，将含噪的可观测状态从未受损的内部记忆隐变量中解耦。通过将表征输入共享的 Transformer 块，并分流为归一化隐藏状态和可观测预测，网络能够在多次迭代中累积推理过程而不会发生漂移。该系统通过在退火课程上进行截断反向传播训练，即便在每个推理步都使用最大高斯噪声抹去未知单元格，也能完成谜题求解，在 10,000 步时对 Sudoku Extreme 达到 99.9% 的完全求解率。定向干预实验证实，隐藏状态的作用类似于具有空间结构的逻辑记录本，而非简单的时钟，这证明了循环机制为主导推理提供了动力，而扩散机制则充当了训练课程。一项新框架（arXiv:2609.01449）为扩散去噪器配备了持久循环记忆，但省去了时间步或迭代计数器，在 10,000 步时对 Sudoku Extreme 达到 99.9% 的精确求解率，在 100 步时对 Maze Unique 达到 98.93%。 (0:00) 该方法并未在测试时进行噪声退火，而是在每个单独的推理步持续注入最大高斯噪声以实现单轨迹探索，使 99.24% 的收敛轨迹锁定在正确解上。 (4:14) 推理中途的因果干预表明可观测棋盘是可舍弃的：在保留隐藏状态的同时重置含噪棋盘，求解率从 82.5% 上升至 88.09%；而重置隐藏状态则会导致准确率骤降至 58.03%。 (5:18) 隐藏状态未接受任何直接监督，完全是在退火扩散训练课程中通过四步截断反向传播作为间接学习器自主发展形成的。 (3:00)

Reading summary

According to research presented from arXiv:2609.01449, a diffusion denoiser stripped of time indexes or step counters can solve complex reasoning tasks by pairing persistent recurrent memory with a disposable, noisy board representation. Two-Stream Architecture and Timestep-Free Memory (0:00) Traditional diffusion models rely on an explicit timestep index $t$ to guide denoising, but the analyzed architecture operates without any clock, step index, or iteration counter. At each step $k$, the network receives only a corrupted board state $x_k$, a set of permanently pinned clue cells, and an internal hidden memory tensor $h_k$ carried over from the preceding step. Unknown cells are embedded, combined with positional information, added to $h_k$, and processed through eight inner passes of a shared transformer block $B_\theta$. The resulting latent $z_k$ splits into two pathways: a LayerNorm branch producing the next recurrent memory $h_{k+1}$, and a linear output mapping emitting the current denoised board prediction $\hat{y}_k$. Because the pinned givens are copied directly into every corrupted board, puzzle constraints remain accessible while the unknown cells undergo continuous variation. The hidden state $h_k$ receives no direct supervision and is never sampled from noise or labels. Instead, it serves as an internal notebook that accumulates computation where input noise cannot erase it. This allows the system to behave as an anytime solver whose reasoning performance scales with recurrent depth, achieving a 99.9% exact solve rate on Sudoku Extreme at 10,000 inference steps and a 98.93% solve rate on Maze Unique in 100 steps. Training Curriculum via Truncated Recurrence (3:00) Training bridges recurrent backpropagation and diffusion noise schedules by executing rollouts between 20 and 160 steps while restricting gradients using truncated backpropagation through time. Gradients flow through only four consecutive denoising steps, after which the computation graph is detached. The numerical memory tensor $h_k$ crosses this boundary intact, where it pairs with a newly sampled corruption of the clean target. The network is trained with an unweighted masked mean squared error applied solely to the prediction branch $\hat{y}_k$, forcing $h_k$ to act as an indirect learner that retains information only when doing so improves downstream predictions. Ablation experiments demonstrate that the diffusion schedule functions primarily as a training curriculum rather than an inference procedure. The model relies on an annealed corruption schedule that begins with heavily corrupted states and gradually introduces cleaner targets. When trained on fixed noise levels, the solve rate drops to approximately 82.73%, and training with zero noise causes complete failure (a 0% solve rate in the reported setup). Maximal Noise as an Exploration Engine (4:14) At inference time, the model exhibits counterintuitive behavior: rather than progressively reducing noise, the system can operate with the noise level fixed permanently at $t=0$. On every inference step, every unknown cell on the visible board is wiped and replaced with fresh, maximal Gaussian noise, while the hidden memory initialized at $h_0 = 0$ is preserved. The observable board undergoes constant amnesia, yet the hidden state retains structured progress, enabling single trajectories to explore candidate solutions without beam search, external verifiers, or candidate selectors. This continuous noise injection acts as an active search mechanism. When inference noise was completely removed in ablations, performance fell sharply from the standard benchmark to 49.39%. Under maximal noise forcing, the trajectory explores alternatives, and 99.24% of trajectories remain locked on the unique correct solution once convergence is reached, with visible cells flipping between valid and invalid assignments until the hidden representation stabilizes. Causal Interventions on the Latent State (5:18) Mid-inference intervention experiments conducted at step 200 of a 400-step rollout confirmed what information the hidden state maintains. Resetting the observable board to pure noise while preserving memory slightly increased the solve rate from 82.5% to 88.09%, demonstrating that the visible board is disposable. Conversely, resetting the memory $h$ to zero caused the solve rate to drop to 58.03%, proving that the board alone cannot sustain reasoning. Spatial and structural modifications to the memory further illustrated its organization. Shuffling memory vectors spatially across cell coordinates reduced the solve rate to 29.38%, showing that memory maintains strict spatial alignment with the puzzle grid. Shuffling memory values globally collapsed accuracy to 0.27%, demonstrating that the latent state is an instance-specific representation of logical resolution rather than an abstract step counter. In addition, widening the hidden state from 64 to 256 channels produced consistent accuracy gains across all compute budgets. The source notes that while the arXiv paper provides explicit pseudocode and architectural specifications, it does not provide a link to an official open-source code repository. The paper demonstrates that the recurrent interface generalizes beyond Sudoku constraints to spatial routing in mazes by replacing relational attention with local cellular-automaton convolutions, but the framework's application to broader reasoning domains remains unaddressed.

Source quotes

[0:00] Mara: computation accumulating somewhere the noise cannot erase. [0:54] Same computation, two destinations. Memory for future reasoning, prediction for the current visible answer. [4:14] The visible board keeps forgetting. The hidden state does not. Noise explores alternatives in X. Memory carries structured progress in H. [6:23] Mara: The clean mental model is a noisy sensor plus a clean notebook. The sensor is xₖ. The notebook is hₖ. The denoiser reads both, writes a prediction, and updates the notebook. [6:23] Diffusion supplies the curriculum. Recurrence supplies the reasoning.

Original transcript

[0:00] Welcome to Hidden State. I'm Mara. [0:02] Today's paper asks a deceptively simple [0:05] question. What happens if a diffusion [0:08] denoiser gets a memory but no clock? [0:11] >> You mean no diffusion time step, no [0:13] iteration number? Then how does the [0:15] network know whether it is on step one [0:18] or step 100? [0:20] >> It does not know. It sees a corrupted [0:22] puzzle, a few fixed clues, and a hidden [0:24] tensor carried from the previous step. [0:26] The surprising result is an anytime [0:29] solver. More steps keep improving the [0:31] answer. [0:32] >> On Sudoku Extreme, the paper reports [0:35] 99.9% [0:36] exact solve at 10,000 inference steps. [0:39] On Maze Unique, 98.93% [0:43] at 100. [0:44] >> Uh [0:46] So, the main story is not pretty [0:48] samples. It is computation accumulating [0:51] somewhere the noise cannot erase. [0:54] Look at the board. A Sudoku instance has [0:57] fixed clue cells and unknown cells. The [1:00] clues are pinned, only the unknowns are [1:02] corrupted. [1:03] >> So, the visible state X sub K is not the [1:06] answer. It is a noisy, changing guess. [1:10] >> Exactly. The paper uses a [1:13] variance-preserving path. [1:15] At T equals zero, the unknown cells are [1:18] maximally noisy. At T equals one, they [1:22] are clean. [1:23] >> And the pinning operation copies the [1:25] clue embedding back into every corrupted [1:27] board, so the givens never drift. [1:30] >> That gives us two different kinds of [1:32] information. [1:34] The observable board can be replaced, [1:36] while the clues and geometry stay [1:38] available to the network. [1:40] >> The same idea transfers to mazes, except [1:43] the maze uses local convolution instead [1:45] of Sudoku's row, column, and box [1:47] attention. [1:49] >> Now, the key diagram. [1:52] First, embed the pinned noisy board with [1:55] E sub X. Add learned position features [1:58] and a clue flag. [2:00] Then add the previous memory H sub K. [2:04] >> So, H sub K is not sampled from the [2:06] diffusion noise, and it is not copied [2:09] from the clean solution. [2:11] >> Right. [2:12] Um it is produced by the model itself. A [2:15] shared pre-norm transformer block B [2:18] theta is applied eight inner times. The [2:21] final latent is Z sub K. [2:24] >> And then the latent splits [2:27] >> into two separately normalized views. [2:31] One branch is H sub K plus one, the [2:34] persistent hidden state. The other [2:36] passes through a linear output map E sub [2:39] O to become the denoised prediction Y [2:42] hat sub K. [2:44] >> Same computation, two destinations. [2:46] Memory for future reasoning, prediction [2:48] for the current visible answer. [2:50] >> That is where the hidden state comes [2:52] from. It is the layer norm of the final [2:55] latent carried forward without fresh [2:58] corruption. [3:00] Here is the part that looks like [3:02] diffusion training, but behaves like [3:04] recurrent training. [3:06] Each roll out samples a length between [3:08] 20 and 160 steps. [3:11] >> But the gradient only travels through [3:13] four denoising steps. [3:15] >> Yes. [3:16] The hidden state survives the boundary [3:19] while its computation graph is detached. [3:22] The next segment starts with the same [3:23] memory and a fresh corruption of the [3:25] clean target. [3:27] >> The loss is a masked mean squared error [3:29] on the prediction branch averaged over [3:32] those four steps. There is no direct [3:34] loss on H. [3:35] >> Which makes the hidden state an indirect [3:38] learner. [3:39] If memory helps future predictions, [3:42] gradient descent rewards the pathway [3:45] that carries it. [3:46] >> So, the curriculum is ordered [3:48] corruption. Start noisy, then gradually [3:51] reveal cleaner targets during training. [3:54] >> And [3:55] the ablation is sharp. [3:57] Fixed noise training drops to about [4:00] 82.73% [4:02] removing noise entirely gives 0% in the [4:05] reported setup. [4:07] >> Diffusion's biggest contribution is [4:09] therefore the training curriculum, not [4:11] necessarily the inference sampler. [4:14] >> At inference, H0 starts at zero. Unknown [4:19] cells start as Gaussian noise. Each step [4:23] runs the same update again. [4:26] >> The paper then tried something [4:27] counterintuitive. Keep T fixed at zero. [4:30] So, every unknown cell receives fresh [4:32] maximal noise on every step. [4:34] >> The visible board keeps forgetting. The [4:37] hidden state does not. [4:39] Noise explores alternatives in X. [4:42] Memory carries structured progress in H. [4:46] >> That makes one trajectory both explore [4:49] and settle. No parallel rollouts, no [4:52] candidate selector, no external [4:54] verifier. [4:55] >> The decoded Sudoku stabilizes [4:58] under this forcing. [5:00] The paper reports 99.24% [5:04] of trajectories remain on the unique [5:07] solution after convergence. [5:10] >> And with no noise at all, performance [5:12] falls to 49.39%. [5:15] Exploration is doing useful work. [5:18] >> The authors test what memory actually [5:20] contains by intervening at step 200 of a [5:23] 400 step rollout. [5:26] >> First intervention. Keep memory, reset [5:29] the observable board to pure noise. [5:31] Performance rises from 82.5 to 88.09% [5:36] under annealed inference. [5:38] >> That says the board is replaceable. [5:40] Second, keep the board, reset memory to [5:43] zero. Solve rate falls to 58.03% [5:49] >> Shuffle memory across cell positions and [5:51] it drops to 29.38. [5:54] Shuffle all values globally and it [5:57] nearly vanishes, 0.27%. [6:01] >> The conclusion is spatial and instance [6:04] specific. [6:06] Memory is not a generic counter. [6:09] It stores where this particular puzzle [6:12] is in its solution process. [6:15] >> Wider memory helps too. 256 channels [6:19] beat 64 across the tested recurrent [6:21] budgets. [6:23] >> One reproducibility note. [6:25] The arXiv source includes exact pseudo [6:27] code and architecture details, but the [6:29] paper page does not link an official [6:31] implementation repository. [6:34] >> So, the code level contract we can [6:35] verify is the algorithm. Pin the clues, [6:38] embed X and H, loop the shared block [6:41] eight times, split Z into H and Y hat, [6:45] and train with four-step truncated [6:46] backpropagation. [6:48] >> Sudoku [6:49] uses relational attention masks. [6:53] Maze uses a local convolutional cellular [6:56] automaton style block. [6:59] Um same recurrent interface, different [7:02] communication topology. [7:05] >> The clean mental model is a noisy sensor [7:07] plus a clean notebook. The sensor is X [7:11] sub K. The notebook is H sub K. The [7:15] denoiser reads both, writes a [7:16] prediction, and updates the notebook. [7:20] >> Training needs an annealed corruption [7:21] curriculum to teach the notebook what [7:23] progress means. Inference can then [7:26] remove the clock and keep the sensor [7:28] noisy. [7:29] >> Diffusion supplies the curriculum. [7:31] Recurrence supplies the reasoning. [7:35] >> This has been hidden state. Keep the [7:39] noise outside the notebook. [7:41] Let's make the claim concrete. This is [7:44] the paper's own Sudoku filmstrip, the [7:46] same puzzle at step zero, then step [7:49] three, five, eight, 10, and finally [7:51] solved. [7:52] >> The board is not magically filled in one [7:54] pass. Wrong cells turn green or red as [7:57] the recurrent trajectory revises them. [7:59] >> Exactly. The observable prediction is [8:01] allowed to be wrong while the hidden [8:03] state keeps the instance-specific work. [8:06] More recurrent steps expose more of that [8:08] work. [8:09] >> And the paper's curve says why this [8:11] matters. With memory, solve rate keeps [8:14] rising toward 100% as K grows. Without [8:17] memory, it plateaus much earlier. [8:20] >> Um [8:21] so the visual proof is a solved board, [8:25] the quantitative proof is the memory [8:27] curve, and the mechanism connecting them [8:30] is H carrying progress while X is [8:32] re-noised.