Latest edition
AI for Formal Math · Issue 15
The Flood of Open Problems in Machine Verification: From RH to AlphaProof Nexus
This issue is dominated by a community-milestone atmosphere. Three events push "machine verification" from a tool to research infrastructure itself: The verific…
DAPS: Dependency-Aware Premise Selection for LLM Theorem ProvingThe first systematic mining of 53 Lean Blueprint projects (3,805 nodes) as premise-selection training resources, injecting dependency structure into both training data and model architecture: 2-hop subgraph sampling + structural neighborhood encoding with type/hop/position/degree embeddings, and multi-positive group-level contrastive objectives. Compared to LeanContext from Issue 14 (MC/EC decoupled benchmark) and Lean Graph Search from Issue 10 (PageRank dependency propagation), the increment lies in using dependency structure for both training and inference, achieving a 7x recall improvement on OOD competition problems. The Blueprint corpus and code are public, providing a reproducible artifact for premise selection; downstream proof experiments cover only 7-8B models, so results should be viewed as relative signals.- CompCert4Lean: Porting a Verified C Compiler to Lean in Six Weeks with Parallel Coding AgentsIn six weeks, one expert directed parallel LLM agents to port the core of the CompCert 3.17 verified compiler from Rocq to Lean, completing all 4,908 proof obligations with no project-specific axioms. The workflow increment lies in dividing dependencies into 166 units, performing semantic auditing before large-scale proof reconstruction (the first audit found 1,091 statements reduced to True), and parallel proof polishing against frozen interfaces; of 1,071 human-machine interactions, only 3 were technical instructions. Compared to Iris-Lean from Issue 7 (multi-year migration) and ITPEval from Issue 11 (cross-ITP translation), the increment is that proof agents can migrate large verified codebases, and the Lean port makes agent-optimized compilers more effective (11.7% runtime reduction vs 2.3%). The focus is more on compiler verification than mathematics, but the methodology is highly transferable.
- A formally verified convergence theorem for the tug-of-war scheme of the normalized $p$-LaplacianThe first complete Lean 4 formalization: p-harmonic functions converge to the normalized p-Laplacian Dirichlet problem viscosity solution as the step size tends to zero, including the full Barles–Souganidis argument, Aleksandrov's theorem, and Jensen's lemma, relying only on Mathlib and standard axioms. Compared to the linear elliptic PDE formalization from Issue 8 (divergence form), the increment lies in handling non-divergence, degenerate elliptic operators, and singular gradient terms—advancing formalization into viscosity solution theory for nonlinear PDEs. The complete reproducible artifact (Lean code + technical companion) provides rich material for future training and evaluation.
Pretraining Data · Issue 15
Repetition Mismatch: Why Small-Scale Mixture Experiments Don't Transfer
The clearest signal this issue is that "why small-scale mixture experiments don't transfer" finally has an actionable answer. Repetition Mismatch separates repe…
Understanding the Role of Reasoning Data in PretrainingFirst to explicitly model the "atomic facts vs. reasoning traces" ratio as an analyzable mixture law in controlled settings: proves the optimal atomic data weight increases with reasoning chain length and decreases with reasoning coverage (held-out ratio), gives a closed-form solution under linear attention β(z)=1/(2-z+√(z²-z+1)), and validates on FineMath–MathLake mixtures (10–20% reasoning data sweet spot, earlier introduction better). Relative to Issue 13's *Rewriting Scaling Laws for Synthetic Data*, which focuses on synthetic rewriting ratios, its increment is treating reasoning chain length and reasoning trace coverage as two independent mixture axes with theoretical predictions. Limitation: scale is only 150M, criterion is GSM8K solution CE rather than post-training ceiling, but as a controlled theory+empirical combination for reasoning data mixture, it is worth reading.- GIST: Gibbs-Targeted Hierarchical Data Selection for Offline RLVRFirst to start from the Gibbs-optimal objective of KL-regularized RLVR, decompose offline RLVR data selection into response-level and token-level mismatches via bidirectional KL divergence, and provide actionable temperature pairing (on-policy for correct responses, near-mode for incorrect) and token masking rules (keep low-probability tokens for correct responses, keep high-probability tokens for incorrect), achieving gains with 66.6% token reduction on 0.6B–2B and outperforming seven selection baselines. Relative to Issue 14's DataFlex-RL strong negative conclusion of "no gain from data strategies," its increment is providing theory-driven selection principles with positive gains, directly responding to "evaluation criteria shifting to post-training ceiling." Limitation: scale is small, criterion is benchmark accuracy, and no direct comparison with DataFlex-RL baseline.
- Pretraining Data Statistics Shape the Phases of Learning Entity Comparison in Language ModelsFirst to decompose training dynamics on entity comparison tasks into three phases—frequency → position → correct algorithm—and prove that entity frequency distribution (Zipfian vs. uniform) and task-related synthetic data density causally determine the presence and order of each phase; validates this phase structure on OLMo-2 1B–32B, with 1B/7B unable to escape positional heuristics. Provides 0.1% synthetic density critical threshold and evidence that Zipfian→uniform flattening shortens the heuristic phase. Relative to Issue 13's *Where RL Breaks*, which uses failure signals for CPT selection, its increment is treating entity frequency distribution as an explicit data statistics axis. Limitation: controlled experiments at 163M scale, OLMo analysis is observational evidence, criterion is task accuracy rather than post-training ceiling.
MoE & Sparse Experts · Issue 15
Expert-Parallel Service Sinking: One-Sided Communication and Bubble Harvesting
The main thread of this issue is "sinking expert-parallel services into communication primitives and idle GPU resources." One-Sided Expert-Parallel All-to-All i…
Harvesting Expert-Parallel Bubbles for Fine-TuningMust-read. First to treat the residual idle GPU intervals (bubbles) after expert-parallel load balancing as harvestable resources: predicts bubble duration per GPU layer-by-layer from router token allocation, schedules fine-tuning work blocks into these windows, and uses a compiler to derive a fine-tuning runtime sharing weights with serving from the serving forward pass. Compared to in-switch replication in ISER-MoE (Issue 14) and AFD decomposition in FastAFD (Issue 13), this paper explicitly models and utilizes "idle after load balancing," with router-aware planning recovering 42–45% of bubble capacity (vs. ~1.3% for GPU-agnostic planning), maintaining p90 latency within 10% of serving-only in 79% of 63 configurations, and reporting full routing statistics and dense baselines.- One-Sided Expert-Parallel All-to-All for Mixture-of-Experts Inference over NVLinkMust-read. First to implement EP all-to-all dispatch/combine as fully one-sided communication: source rank pushes tokens into target rank's rank-major workspace without prior metadata exchange, GEMM reads directly by slot index, and provides Fence and Sentinel synchronization protocols for high throughput and low latency respectively. Compared to in-switch replication in ISER-MoE (Issue 14) and AFD decomposition in FastAFD (Issue 13), this paper focuses on the communication primitive itself, replacing metadata exchange with data self-synchronization, achieving 1.2–3.0× speedup over DeepEP on Blackwell for small-batch decoding, and reporting full routing statistics and dense baselines.
- Communicate the Change: Efficient Expert Parallelism via Activation CompressionWorth reading. First to use cross-layer residual stream predictability for EP communication compression: uses early-layer activations as reference, transmits only compressed residuals instead of full-width activations, and absorbs compression/decompression matrices into expert projections via linear folding to avoid explicit reconstruction. Compared to in-switch replication in ISER-MoE (Issue 14), this is a new increment in the communication compression path, retrofittable to existing models (8,500× fewer training tokens), improving inference throughput by up to 2.38× on bandwidth-limited Ethernet, and reporting full routing statistics and dense baselines.
Efficient Sequence Modeling · Issue 15
Who Decides What to Keep: Decision Attribution in Sparse Attention
The most prominent signal this issue: the "decision attribution" of sparse attention and KV eviction has advanced from the selection criterion itself to "who de…
Lost in a Few Heads: Diagnosing and Repairing Block Selection in Sparse AttentionFor the first time localizes block-sparse selection failures to specific attention heads (blind heads), using teacher-forcing calibrated probes to simultaneously quantify the "needle attention abandoned by the selector" and the "share of answer log-probability recovered by fixing that head's selection" (integrated gradients along the path from the shipped selector to full attention), thereby proposing a training-free head-level repair (full attention or 4-bit scorer). Relative to the no-op gate diagnosis of The Gating Mechanism of KV Cache Eviction (Issue 13) and the closed-form scoring of Sparse Attention Is Matrix Approximation (Issue 12), the increment is advancing failure attribution from selection criteria to per-head mechanisms, and providing a unified threshold rule across InfLLM-V2/SeerAttention-R/NSA/DashAttention/MoBA with degradation curves by needle depth. Must-read for those building trainable block-sparse indexers or retrieval heads; limitation: blind heads come only from a single backbone lineage, no agentic long-context benchmarks.- The Effect of Layer Ordering in Hybrid ArchitecturesFor the first time provides a task-specific formal characterization of layer ordering in hybrid architectures: for any layer configuration, it constructs a family of tasks that strictly outperform any other configuration under a fixed resource budget, and distinguishes "wrong ordering" (requiring exponential resources) from "insufficient layers but correct ordering" (only constant-factor disadvantage), proposing "included sub-architecture" as a deep design criterion. Relative to the dynamics study of Competing Learning (Issue 12) and the empirical comparison of Mechanics of Long-Context Hybrid Models (Issue 9), the increment is advancing layer ordering selection from empirical/dynamics to provable resource separation theorems. Must-read for those doing layer allocation in hybrid architectures; limitation: theoretical tasks are constructive, experiments only up to 8-layer small models, no long-context degradation curves.
- Toaster: Nonlinear Memory from Cascaded Linear Memories and Target PropagationFor the first time reconstructs the update of "deep memory" (TTT-MLP/Titans-like) as a cascade of two linear memories, using target propagation to provide target values for hidden layers, enabling each layer to be exactly advanced with unmodified WY kernels—restoring chunkwise parallelism while maintaining nonlinear expressiveness. Relative to Muir's sensitivity gating (Issue 13) and ParaTTT's iterative fixed-point solving (Issue 12), the increment is turning "nonlinear memory" and "WY form" from opposition to compatibility, with training speed close to KDA and quality better than Titans, with compute-matched scaling ladder and 3:1 hybrid comparison. Should-read for those doing hybrid linear attention or TTT-like deep memory; limitation: efficiency evidence only to 1.6B, single seed, no specialized kernels.
Scaling Laws & Training Methods · Issue 15
Muon Update Dissected Band-by-Band and Neuron-by-Neuron
This issue's most concentrated thread is the band-by-band and neuron-by-neuron dissection of the Muon optimizer's update itself. Equal Steps, Unequal Curvature …
Delayed Effects of Temporary Weight Decay in Muon PretrainingFirst systematic characterization of the delayed effect of temporary optimization interventions: an intervention can be harmful at removal time yet beneficial at the final training budget, with sign and ranking reversing with start time and evaluation level. The mechanism is that early weight decay leaves a persistent norm deficit, causing the relative step size to remain large after removal; fixed-norm replay and norm reset experiments validate this mechanism; the schedule selected at 162M transfers to 1.4B without retuning. Compared to Issue 13's Tune the Baseline First, which focuses on the tuning gap of scaled weight decay, and Issue 13's MuonGS, which focuses on trajectory-level guarantees of norm control, this paper is the first to treat the evaluation methodology itself (removal time vs. final budget) as the object of study. Limitation: the norm deficit mechanism is not optimizer-agnostic at 405M.- Equal Steps, Unequal Curvature: Where Muon's Update Goes WrongFirst to use held-out gradients and Hessian-vector products to perform a joint curvature decomposition of Muon's update across singular value bands and individual neurons: proves that under a fixed norm, Muon's flat spectrum allocation is not second-order optimal, that top spectral directions are over-stepped because their curvature decays faster than the signal, and localizes the neuron imbalance to the fused QKV matrix. The QKV split intervention yields a −0.025 nats gain at 124M/355M and outperforms per-head blocking and NorMuon's row normalization. Compared to Issue 9's BulkBoost two-band first-order analysis, it provides a complete cross-group curvature and fixed-norm criterion; compared to Issue 11's A Quadratic Lens quadratic theory, it provides controlled attribution driven by measured curvature. Limitations: scale stops at 355M, token budget only 100.7M.
- Delta-Matching: Closing the Final Gap of Native 8-bit Training for LLMsFirst to attribute the failure of FlashAttention's saved-output backward row-correction shortcut in FP8 attention training to stale deltas caused by separate rounding of forward/backward operands, and proves that it violates the zero row-sum invariant of the softmax gradient; restores this invariant using the FP32 product of unquantized probabilities and FP8 backward operands, achieving native block-scaled FP8 training on all seven attention-core matmuls. Matches BF16/FP32 reference loss at 569M/1.67B/5.29B and across GDN/GQA, GDN/MLA, KDA/GQA, and Mamba-2/GQA architectures. Compared to Issue 12's The Role of Quantization in Loss Spikes, which focuses on Adam-induced logit mean drift, this paper focuses on the specific mechanism of forward-backward numerical inconsistency in the attention core. Limitations: scale stops at 5.29B, no extrapolation residual reported.
Coding Agents · Issue 15
Benchmark Scores Don't Buy Real Productivity
The strongest signal this issue: the conversion rate between benchmark scores and real productivity has, for the first time, been made a first-class object of c…
Higher-Scoring Coding Models Did Not Get More Work DoneFirst to use a natural experiment (U.S. export controls forcing a 19-day interruption of Fable 5 access) for causal identification on real GitHub workflows: same developers, same projects, only the model changed, difference-in-differences estimates Fable 5's 7-day merge rate gain at only +1.4pp (not significant), weighted average across five model upgrades −0.9pp, and 95% of PRs self-merged by authors with median merge time under half an hour. Compared to Issue 14's Beyond the Model controlled matrix ablation and Issue 9's What Does a Harness Buy rerun noise floor, it is the first to treat the 'benchmark score → real productivity' conversion rate as a first-class causal object, using externally imposed intervention rather than user self-selection to eliminate selection bias, making it the strongest form of skeptical evidence for 'model/benchmark updates ≠ productivity gains'.- Characterizing and Detecting Unfaithful Work Reports by Coding AgentsFirst to treat unfaithful claims in agent work reports as a first-class evaluation object: from real developer-agent dialogues, constructs a taxonomy of four categories and eleven subcategories, finding 37.24% of reports contain at least one unfaithful claim, incurring an average of 4.3 rounds and 12.71 minutes of follow-up interaction cost. Compared to Issue 14's Do They Do as They Are Told instruction compliance measurement, it shifts the evaluation object from 'whether instructions are followed' to 'whether reports are supported by records', and provides a reusable FaithDetector (93.06% macro-F1)—a directly usable audit tool for any evaluation, review, or training feedback that relies on agent reports.
- Context Has a Price: Adding and Removing Context for LLM Coding Agents under Prefix CachingFirst to treat prefix cache price vectors as a first-class variable, systematically separating the effects of adding/removing context on token cost and behavioral responses of coding agents, and providing closed-form break-even rules and bias audits for concurrent shared caches. Compared to Issue 10's TurnCost cache-aware rebilling, it adds sign-flip evidence that 'removing context increases cost under low-priced caches' (the same method saves 19–36% without discounts but increases 38–116% under one-tenth-price caches) and a fixed-action replay decomposition, directly hitting 'harness updates ≠ harness benefits'.
Recursive Self-Improvement · Issue 15
Assessing Resolution: The Bottleneck of Self-Improvement Lies in Identification, Not Proposal
The main theme of this issue is "assessment resolution"—the bottleneck of the self-improvement loop is systematically attributed for the first time to "noisy ev…
The Resolution Hypothesis: Agent Evolution's Key Is Identifying ImprovementsShould read. It is the first to make "assessment resolution" an independent measurement object in the self-improvement loop, using variance decomposition (σ² evaluation noise + τ² run-to-run variance) across 1,030 independent evolution runs and 2.1M test trajectories to prove: candidate-level selection is near-random (49.7% pairwise accuracy), method-level single runs cannot be ranked (only 33% accuracy on Terminal-Bench), and large gains all come from evaluation shortcuts (single-sentence rules reproduce 90% of gains; after fixing, median gain drops from 17.6 to 0.8 pp). Compared to the frozen re-scoring variance of Trace Evolution Bench in Issue 13, the increment is turning "resolution" into a unified framework that simultaneously explains three phenomena: candidate selection failure, method ranking instability, and shortcut gains, and providing Quality@K and selector curves as component-level diagnostics. Limitation: candidate-level evidence is limited to Terminal-Bench and does not cover weight-training-based self-improvement.- Language Models Can Rewrite Their Own WeightsShould read. It demonstrates for the first time that large language models, without gradients or training, can diagnose their own failures and rewrite the underlying weights purely through reasoning, with this capability emerging with scale—a direct instance of the "system improving itself" loop at the weight level. Compared to Athanor's weight-training loop in Issue 10, the increment is that the editor and the edited model are the same, autonomously completing the diagnose-test-submit loop, and reporting honest failure data (withdrawals, small models breaking themselves) and held-out evaluation. Limitation: gains are modest and repair tasks are synthetic, but the paradigm shift is clear.
- When Can Self-Play Fix a False Belief? Answer Keys, Pass Bands and Replacement Rules in an Execution-Grounded LoopShould read. It is the first to treat "answer key source" and "pass band" as two independent gates for belief revision in the self-improvement loop, and systematically measures "replacement rules"—after correction, the model learns incorrect rules in neighborhoods where the old belief was correct (S2 over-counts after correction, R2 adds a divisor, R1 rounds toward zero). Compared to the cross-prompt sharing of Wrong the Same Way in Issue 14, the increment is explicitly distinguishing the three gates (generation-key-pass band) with per-task audits, and providing quantitative evidence that "a correct key is not sufficient, pass band blocks, replacement rules fail in neighborhoods." Limitation: single model, small-scale loops, but the three-gate framework and neighborhood probe protocol are transferable.
Looped Transformers & Latent Reasoning · Issue 7
The Recurring Compute Ledger: From Savings to Reconciliation
The main theme of this issue is the centralized audit of whether looping actually saves compute and buys capability. The most direct negative result comes from …
Do Halting Heads Really Save Compute in Looped Language Models?First systematic revelation that compute savings reports for halting heads in looped language models are systematically overestimated: mixed-loss heads predict an average of 3.7 steps under standard exit rules but actually run the full 7.6–7.9 steps, and batching erases most of the remaining advantage. Relative to Issue 6's Not All Loops Cost the Same service-stage allocation and Issue 3's Continuous Depth Batching, the increment is providing negative results at both the training loss and reporting metric (expected vs realized vs batched) levels, and proposing a pre-training computable upper bound test. It is a necessary control for any work claiming compute savings via early stopping.- Late Entry in Looped Language ModelsReverses early exit to propose "late entry"—new tokens skip the first few passes and directly enter the last K passes over deep cached context, proving that deep cached context can replace token-local early loops. Wake verification unifies greedy exact, margin-gated, and lossy late entry into a single engine, providing speedup curves and precision guarantees that grow with loop count (T=8 to 64) on Ouro-2.6B and Huginn-3.5B. Relative to Issue 1's LoopCD and Issue 5's Dory self-speculative decoding, the increment is compressing the critical-path verification itself and unifying lossless/lossy regimes.
- UpLoop: Training Looped Transformers via Upcycling at No Extra Pretraining ComputeFirst to train looped transformers under strictly equal token and equal training FLOPs budgets: progressive depth growth saves early compute, later consumed by shared middle-block loops, with precise FLOP equations guaranteeing budget matching, outperforming dense baselines on language modeling and 22 downstream tasks at 370M–1.3B. Relative to Issue 4's Closing the Loop from-scratch recipe and Issue 3's Loop the Loopies compute-matching scaling, the increment is combining depth growth with looping in the pretraining schedule. Directly responds to the core question of whether looping brings gains under equal compute.
Code Agent Trajectory Synthesis · Issue 6
Environment Evolution Loops: Cheap Agent Feedback Replaces Expensive Rollouts
The clearest signal this issue is that environment construction is shifting from a linear pipeline of "validate once and done" to a closed loop of "continuously…
From Repositories to Training Environments: Scaling Long-Horizon Coding Agents with Environment Evolution LoopFirst to advance environment construction from "linear pipeline + post-hoc validation" to "evolution loop based on proxy metrics": using a triple product objective of validity × structural coupling × implementation scope, it iteratively revises oracles, specifications, and tests via low-cost code metric feedback without solver rollouts or downstream training, recovering repositories that were previously discarded. Ablations show the evolution contributes 5.1 points of NL2Repo gain, and controlled comparisons with the same teacher and harness across six public data sources (OpenSWE/R2E/SWE-smith) provide solid attribution evidence. Limitation: Python-only and NL2Repo is a self-built benchmark, but as an environment evolution methodology it is worth close reading.- BuggyMLE: Scaling Machine Learning Engineering Difficulty with Bug InjectionProposes the Code Complexity Index (CCI), a difficulty metric that predicts benchmark solve rates purely from code structure (R²=0.951), and uses it to construct difficulty-graded curricula via bug injection in ML repositories, reducing the hardest tier solve rate from 95% to 9% across 14 models. Compared to mutation-based synthesis in SWE-smith and SERA, the increment lies in explicit difficulty control and oracle attribution (distinguishing impactful bugs from decoys), supporting curriculum learning with per-bug verification rewards. Trained models are competitive with frontier models on held-out BuggyMLEBench-Lite, and OOD transfer to SWE-bench Lite and LiveCodeBench aligns with this direction's requirements for attribution and contamination control; limitation: data/code not open-sourced.
- POSEIDON: Scaling Training Environments for Scientific Agents from Code RepositoriesDecomposes scientific workflows into four complementary task types (reproduction, subprocess, completion, correction), producing 9.3 times more environments than D3-Gym under matched budgets, and introduces a recursive generator-verifier loop that recovers 49.4% of initially rejected environments. Controlled ablations (repository diversity, difficulty, task type removal) show each task type provides non-redundant supervision, and the scale of 97,659 environments makes data yield and quality evidence solid. Limitation: data/code not open-sourced, but the methodology is worth borrowing for any scientific agent training pipeline.