Friday, September 4, 2026 — The Daily Diff

Claude autonomously formalizes the proof of Fermat's Last Theorem

Automating mathematical reasoning just crossed a major threshold. Claude has generated the first complete, computer-checked proof of Fermat's Last Theorem in the Lean proof assistant, working largely autonomously over eleven days.

To accomplish this, the system produced thirteen million lines of Lean code and verified 29,500 intermediate theorems. Rather than hallucinating plausible-sounding mathematical prose, the agent operated against a strict verification harness where every single proof step must compile and satisfy core logical axioms.

This demonstration illustrates how long-horizon autonomous agents can navigate massive search spaces when paired with deterministic verification environments. For systems engineers building agentic workflows, the lesson is clear: ground the model against an unyielding compiler or test harness, and let reinforcement mechanisms explore the solution space.

Formal verification is shifting from an expensive human bottleneck into an automated pipeline driven by autonomous reasoning models.

By Garrin·HN ›·Discuss ›

Next-token prediction is an incomplete mental model for LLMs

Treating modern large language models as mere next-token predictors misses the entire architectural shift driven by modern post-training. While the final inference loop technically emits one token at a time, the underlying policy is no longer just mimicking text distributions found in pre-training corpora.

During reinforcement learning with verifiable rewards, the training signal does not provide a correct target token at position N. Instead, the model explores reasoning trajectories, and the optimization gradient rewards entire coherent chains that yield valid terminal answers. The model learns to allocate search steps, back-track, and structure intermediate problem-solving traces.

Engineers who design prompts and harnesses based strictly on surface-level token probabilities often misunderstand why models fail on reasoning tasks. Once you view the model as an optimized search policy shaped by reward verification rather than a text predictor, context design becomes significantly more intuitive.

Tokens are simply the output medium, not the mechanism driving the underlying reasoning behavior.

By theanonymousone·HN ›·Discuss ›

Why general horizontal scalability fails under transaction contention

General purpose distributed relational databases often pay an enormous latency penalty when handling write contention across network boundaries. Systems like CockroachDB, Spanner, and Aurora DSQL rely on distributed consensus protocols paired with two-phase commit, which introduce multiple network round trips whenever transactions contend for identical keys.

Horizontally scaling storage is relatively straightforward, but horizontally scaling contended OLTP computation violates basic physics. When concurrent writers update shared state across nodes, distributed locking and transaction restarts degrade throughput far below what a single optimized machine can process entirely in memory. SpacetimeDB addresses this by keeping relational state execution local while scaling parallelizable read paths and background processing independently.

Blindly distributing your relational database does not solve architectural contention; it only multiplies the network latency of every lock.

By Pengcheng Xu·HN ›·Discuss ›

Why coding agents favor grep over semantic navigation

Giving an LLM agent an LSP semantic index seems like an obvious upgrade over simple string search, but recent benchmarks reveal the opposite result. In code-finding and editing benchmarks across Claude models, coding agents consistently defaulted to grep, and forcing them to use semantic navigation often reduced overall task success.

The failure is not about model intelligence. High-precision tools like language servers return narrow symbols and jump references, which strip away the surrounding contextual lines that a model requires to plan its next edit. Grep returns raw text matches alongside surrounding lines, giving the model immediate local context in a single call.

Tool design for autonomous agents requires optimizing for context density rather than symbolic perfection. When building harnesses for agentic workflows, providing messy but context-rich output consistently beats structured, minimal interfaces.

By Tomas Vondra·HN ›·Discuss ›

Postgres random page cost compensates for incomplete cost models

Setting Postgres random_page_cost to match raw physical disk latency often degrades query performance instead of improving it. Modern NVMe drives exhibit random read latencies close to sequential access, yet lowering this parameter naively can cause the query planner to favor disastrous nested loop scans.

The PostgreSQL cost model relies on random_page_cost not as an isolated disk benchmark, but as a blunt counterweight for unmodeled system dynamics. In real workloads, operating system page cache hit rates, CPU cache locality, and readahead mechanisms skew the true cost of sequential scans well beyond pure I/O speed.

Rotational SATA disks produce an empirical random_page_cost around 125, nearly thirty times the default setting of 4.0. If database administrators had configured cost parameters to match raw hardware metrics, the optimizer would have broken by rejecting index scans almost everywhere.

The optimizer cost model is an interconnected heuristic, so tuning parameters against synthetic disk speeds routinely backfires.

By smaddrellmander·HN ›·Discuss ›

Lossless token retrieval across every layer misallocates compute

Full attention across million-token contexts is an inefficient use of compute when most tokens do not require lossless retrieval. GLM-5.3-Flash addresses this memory bottleneck by abandoning uniform attention in favor of a hybrid memory hierarchy.

The model splits its 45 layers into 34 Kimi Delta Attention layers and only 11 sparse Multi-head Latent Attention layers. At one million tokens, the sparse layers attend to just 2,048 positions, which is approximately 0.2 percent of the sequence context.

Instead of retaining every key-value pair across all layers, the delta attention layers maintain a fixed-size recurrent state matrix that updates dynamically during inference. This acts as fast weights, forcing the network to compress sequence history into a compact representation rather than ballooning KV cache memory.

The takeaway for inference infrastructure is clear. Treating context retention as a uniform problem wastes memory bandwidth. Combining lossy recurrent compression with targeted sparse attention delivers massive context windows without linear cache bloat.

Hardware efficiency will belong to architectures that rethink memory tiers rather than brute-forcing full attention.