Why the Same AI Model Takes Ten Times Longer on the Same Sudoku

Source: Fractal basins trap latent reasoning

Paper was published on September 04, 2026

This episode was AI-generated on September 8, 2026. The script was written by an AI language model and the host voices were synthesized by Eleven Labs. The producer is not affiliated with Anthropic or Eleven Labs.

Freeze the puzzle, freeze the weights, and change nothing but the random numbers a reasoning model starts from — nudge them in the fourteenth decimal place, and it can take ten times longer to solve an identical Sudoku. A group of physicists mapped that behavior and found a fractal that survives a thousandfold zoom, plus a mechanism borrowed from asteroid orbit tracking. The punchline: the expensive moments aren't confusion, they're near-misses, and a model becomes competent and chaotic in the same four training steps.

Key Takeaways

• Why thinking time in a looped reasoning model depends on a throwaway random seed — and why the answer it lands on doesn't
• The exchange rate that makes this operational: 10x more predictable runtime costs ~10,000x more precision in your starting state, at every zoom level down to 1e-14
• What the model is actually holding when it stalls: saddle points decode into maze dead ends and Sudoku grids with a repeated digit — near-misses, not confusion
• The training experiment where accuracy jumps and basin entropy jumps in the same ~4 steps, with chaos appearing only in variables requiring multi-step deduction
• Three seams in the paper, including a headline difficulty plot that's partly circular because both axes come from the same field of pixels
• Why the reported denial-of-service attacks on frontier models may be finding basin boundaries rather than hard prompts

• 00:00 — A chaos party trick, run on an AI
  The cold open: the same model, same puzzle, same weights, with only the random starting vector nudged in the fourteenth decimal place, can take ten times longer — and the map of fast versus slow seeds is a fractal.
• 02:33 — Does the seed even matter?
  Tyler lays out the conventional explanation — harder problem, bigger search space, seed is just noise — and Finn shows it makes no prediction about runtime at all, citing adversarial prompts that burn 10x the compute of near-identical benign ones.
• 05:06 — What makes this experiment possible at all
  Finn explains recurrent-depth 'looped' models — one block of weights applied repeatedly to a hidden vector — and Tyler puts the chain-of-thought caveat on the table up front.
• 07:39 — Sweeping a plane through 50,000 dimensions
  The method: freeze puzzle and weights, turn off injected noise, sweep a 2D plane through the ~50,000-dimensional starting state, and color each pixel by how many loops the model needed.
• 10:13 — Pretty picture, or actual fractal?
  The zoom test, basin entropy, and the operational number: to make runtime 10x more predictable you'd need to specify your starting state about 10,000 times more precisely.
• 09:20 — Plinko, mountain passes, and asteroid orbits
  Transient chaos explained: reliable destination, unreliable route, with saddle points as the delaying 'pegs' — localized using the Fast Lyapunov Indicator, a tool built for asteroid orbit stability.
• 15:19 — What's sitting at the expensive spots
  Decoding the latent state where slow trajectories loiter reveals near-misses — maze dead ends and Sudoku grids with a repeated digit — and links it to the classical constraint-satisfaction picture of hard instances.
• 17:53 — Competence and chaos in four steps
  The causal experiment: training a small looped transformer on eight equations and eight unknowns, accuracy jumps and basin entropy jumps in the same ~4 steps, and only the core variables requiring multi-step elimination produce positive Lyapunov exponents.
• 20:26 — Three seams, one that carries weight
  Tyler's critique: the framing-versus-tested gap, the fact that determinism is engineered by switching off inference noise, and the partly circular headline plot where basin entropy and mean convergence time come from the same pixels.
• 22:01 — A probe, not a fix
  What the result actually buys — per-instance difficulty via basin entropy, a training signature to watch for, a re-reading of denial-of-service attacks — and the closing question of whether unpredictable thinking time is structural or an engineering artifact.

Recommended Reading

• Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach — The recurrent-depth architecture at the heart of the episode — a looped block iterated on a randomly initialized hidden state, which is exactly what makes the basin-sweeping experiment possible.
• Hierarchical Reasoning Model — The small looped model behind the episode's claim that seven-million-parameter latent reasoners beat far larger LLMs on Sudoku, mazes, and ARC-AGI — the tasks whose basins get mapped.
• Optimization hardness as transient chaos in an analog approach to constraint satisfaction — The closest prior work Finn cites: a hand-designed continuous SAT solver whose basins go fractal as constraints tighten, making the new paper's point that nobody had to design this behavior in.
• Deep Equilibrium Models — The theoretical backdrop for treating a fixed-point-iterating network as a dynamical system whose convergence behavior — not just its answer — is the object of study.