Papers for

reinforcement learning engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Algorithm achieves optimal learning speed in episodic reinforcement learning

Closing the Log Gap: Minimax-Optimal Regret for Episodic RL

Abstract: In this paper, we study the regret minimization problem in episodic tabular MDPs. Our algorithm achieves the first expected regret bound scaling as $\sqrt{H^3 S A K}$ for sufficiently large $K$, where $H$ is the episode length, $K$ is the number of episodes, and $S$ and $A$ are the numbers of states and actions, respectively. Our method is the first to match the minimax lower bound \emph{without extra polylog factors}. We introduce a variant of UCBVI which does not maintain strictly optimistic estimates, and uses MOSS-style exploration bonuses whose logarithmic terms adapt to both visit counts and estimated variances. A key challenge is controlling the propagation of errors caused by under-optimism, which we accomplish in an occupancy-weighted way, avoiding logarithmic overhead that would be incurred by uniform-over-rows concentration. Our analysis develops time-uniform and variance-aware concentration bounds that may be of independent interest. As a corollary we also develop an algorithm for $(\varepsilon, δ)$-PAC best-policy identification, which is the first to match the $Ω\big(H^3 SA\log(\frac{1}δ)\varepsilon^{-2}\big)$ minimax lower bound up to constants in some regimes.

Thu 29 OctMachine Learning
The gist
This paper addresses how to make computers learn the best actions in a limited number of tries within a game or task that has many steps. The authors developed an algorithm that learns almost as fast as theoretically possible, without extra slowdowns usually caused by complicated calculations. Their approach adjusts how it explores the task, balancing risk and uncertainty to improve learning speed. They also provided a new method to identify the best strategy reliably with fewer samples than previous methods.
Open → 2610.40165v1

Policy updates reveal when skills become less useful in AI agents

Before the Next Rollout: Diagnosing Skill Utility Shifts from Policy Updates

Abstract: Skill-evolution methods typically analyze execution trajectories to guide agent skill refinement. However, policy updates can change the behavioral effects and marginal utility of an unchanged skill. Attribution based on earlier trajectories may therefore no longer reflect the skill's contribution under the updated policy. Moreover, trajectory failures can arise from multiple factors, making individual skill contributions difficult to isolate. We evaluate whether policy-update signals contain predictive information about changes in skill marginal utility. At fixed contexts from pre-update training rollouts, we measure how policy updates change the contrast in token preferences between skill and control conditions. Combining these interaction shifts with advantage estimates yields reward-directed readouts for diagnosing utility changes. The readouts reuse existing training rollouts and require only forward passes for single-step action scoring, without additional post-update rollout evaluation. Our experiments show that policy updates can alter skill marginal utility and that policy-update readouts carry diagnostic information for identifying skills with declining utility. Integrating readout-guided prioritization into skill evolution improves downstream performance while reducing policy and editor token consumption.

Thu 29 OctArtificial Intelligence
The gist
When AI agents learn, they use different skills to decide actions. Sometimes, updating the agent's decision strategy changes how useful each skill really is, even if the skill itself hasn't changed. The authors show a way to spot which skills have become less helpful after these updates, without needing extra tests. This helps focus improvement efforts on skills that matter most under the new strategy.
Open → 2610.39358v1

Game theory clarifies state similarity in undiscounted reinforcement learning

Game-Theoretic Foundations for Undiscounted Bisimulation Metrics

Abstract: Bisimulation metrics offer a principled notion of task-relevant state similarity in reinforcement learning, but existing constructions and methods are largely confined to discounted MDPs, where contraction arguments ensure well-defined fixed points and downstream guarantees. We develop a unified foundation for bisimulation metrics in undiscounted settings, that is total- and average-reward problems, by replacing the standard operator-centric view with a game-centric one: we interpret prior metric operators as Bellman-Shapley operators of zero-sum turn-based games and define metrics as the corresponding game value functions, yielding unique definitions even when $γ=1$. This game-theoretic foundation facilitates transfer of dynamic-programming theory and algorithms. We also use this game-centric perspective to characterize how metric finiteness depends on structural properties of the underlying MDP and motivate certain directed metrics that remain finite in weakly communicating MDPs. We further introduce an abstract framework for modifying the games' action spaces, allowing general transition coupling sets, that recovers many existing metrics and guides new constructions. Finally, we prove that these metrics bound total-reward and, when the optimal gain is state-independent, optimal relative value differences. We also provide error and suboptimality guarantees for aggregation-based planning in total- and average-reward settings.

Wed 28 OctArtificial IntelligenceComputer Science and Game TheoryMachine Learning
The gist
Finding how similar different situations are can help machines learn better how to act over time. Usually, this similarity is easier to measure when future rewards are less important, but the authors worked on cases where all future rewards count equally. They used ideas from game theory to make this similarity measure well-defined and useful, even when standard methods fail. This helps in understanding and planning for tasks where rewards are not discounted over time.
Open → 2610.38313v1

EasyProver scales up automated proofs for realistic code verification

Scaling Lean Theorem Proving for Real-World Code Verification

Abstract: We present EasyProver, a Lean proving system built from recursive agents with isolated contexts, asynchronous search, parallel tactic probing, and an elastic elaboration service. Using an off-the-shelf frontier model with no additional training, it proves 669/672 PutnamBench problems and all six IMO 2026 formalizations and resolves 597/600 NTP4VC verification conditions and all 189 VERINA tasks by proof or refutation. Because these benchmarks are close to saturation, we also introduce Aegis, which converts competitive programming problems into much harder verification tasks over real implementations. The pipeline writes safe Rust solutions, translates them into Lean with Aeneas, generates specifications, and labels each frozen statement with a kernel-checked proof or refutation. It produces 2,045 differentially validated Rust-Lean program pairs and 11,533 candidate specifications. Unlike hand-written benchmarks, these tasks carry implementation-level obligations from fixed-width arithmetic, explicit failure, generated loops, casts, and functionalized mutation. On a stratified sample of 2,000 statements, EasyProver proves 1,054 (52.7%) within a 30-minute budget per statement. The same tasks can also be used to benchmark other provers and as rewards for reinforcement learning.

Wed 28 OctComputation and LanguageArtificial IntelligenceLogic in Computer Science
The gist
Verifying that computer programs are correct is very hard, especially with real-world details like how numbers behave and how code can fail. The authors created EasyProver, a system that can automatically prove or refute many code verification problems quickly and accurately using smart techniques like working in parallel and isolating parts of the problem. They also built Aegis, which turns competitive programming problems into more difficult tests involving real implementations, producing lots of examples of verified Rust and Lean programs. This work helps make automatic checking of complex code more practical for software developers.
Open → 2610.38174v1

Latent world models fail to accurately capture environment dynamics

Understanding the limits of latent world models

Abstract: World models are widely proposed as core components for enabling agents to reason over long temporal and spatial horizons. Yet current evaluations often emphasize task performance while providing limited insight into whether learned world models acquire predictive latent dynamics that reflect the underlying structure of the environment. Here we introduce the concept of faithful latent world models as an equivariance condition between the environment's transition map and the learned latent dynamics. We propose latent rollout consistency (LRC) as a metric to evaluate action-conditioned latent prediction. Strikingly, we find that across the studied state of the art latent world models, none solves the task by actually faithfully modeling the dynamics of the environment.

Tue 27 OctMachine LearningArtificial Intelligence
The gist
Predicting how things change over time is important for making smart decisions. The authors looked at models that try to understand and predict environments internally, called latent world models. They found that even the best current models don't truly learn the actual dynamics that govern how the environment changes. This means these models solve tasks without fully understanding the underlying rules of the world they operate in.
Open → 2610.37588v1

New optimal regret rates found for kernel based reinforcement learning

Minimax Regret for Sobolev Kernel-Based Reinforcement Learning

Abstract: We study the minimax regret rate for episodic kernel-based reinforcement learning, where the expected reward and transition density belong to a Sobolev reproducing kernel Hilbert space, with continuous state and action spaces, and adversarial initial states. For Sobolev smoothness parameter $ν>0$, state dimension $d_S$, and action dimension $d_A$, we prove that the minimax expected regret over $T$ episodes is $\widetildeΘ(T^{\max\{e_A,e_B\}})$, where $e_A=\frac{ν+d_A}{2ν+d_A}$, $e_B=\frac{ν+d_A+3d_S/2}{2ν+d_A+2d_S}$ with the other model parameters fixed. The two exponents reflect the distinct difficulties of action selection and learning across states. We introduce Sobolev Optimal Value Iteration (SOVI), which attains this rate from observed rewards and transitions. For fixed smoothness and reference-kernel lengthscale, its regret bound has a prefactor polynomial in the state-action dimension $d=d_S+d_A$, horizon $H$, transition and reward RKHS norm bounds $u,B_r$, and kernel norm-comparison factor $Λ$, up to logarithmic factors. The algorithm separates initial action selection from continuation-value estimation and combines local polynomial approximation with the shared RKHS structure of the approximation errors. Our matching upper and lower bounds determine the optimal dependence on the number of episodes for Sobolev kernel-based reinforcement learning. Thus, we partially address the open problem in Vakili(2024) under the condition of the Sobolev kernel setup.

Sun 25 OctMachine Learning
The gist
When computers learn how to make decisions step-by-step in complex situations, it’s important to understand how well they can do over time. This paper studies learning when the system’s behavior is smooth and continuous, described by a mathematical space called Sobolev. The authors identify the best possible rate at which errors (regret) improve as the learner experiences more episodes. They also create an algorithm called SOVI that achieves this best rate, separating initial decisions from ongoing learning. This work answers an open question about limits of learning in continuous decision problems under certain smoothness assumptions.
Open → 2610.34045v1

Approximate prediction limits under feedback in universal agents

Approximate Universal Prediction under Interaction

Abstract: Bayesian mixtures, and Solomonoff induction in particular, provide an idealized model of prediction learned by minimizing population log loss, and they underlie universal agents such as AIXI. An agent that plans with an approximation of such a predictor decides where that predictor is evaluated, and a planner can be drawn toward branches on which its model is optimistic. We study which approximation guarantees survive this feedback. For normalized finite-horizon causal mixtures, the transfer coefficient factors into a policy likelihood ratio and task evidence available before each prediction, so task rarity and action-branch rarity can compound. Within one fixed universal mixture, infinitely many computable environments admit excess prediction error of order $κη\,2^{K(μ)}$, where $η$ is the training KL budget and $κ$ measures policy coverage. This order is sharp, and for each target a computable predictor attains it at a suitable finite horizon, so computability alone does not remove the penalty. For bounded returns, value error is controlled by the probability of entering a poorly covered branch plus a square-root term in $η$. Both terms are necessary, and finite maximum coverage ratios are not required. Motivated by the mentor override of Golden Handcuffs, we derive margins for preserving deferral decisions and conditional KL budgets with an unavoidable inverse-history-probability penalty, and a counterexample separates agreement of deferral decisions from task-wise event avoidance. The guarantees apply to any predictor architecture that meets explicit population approximation and coverage conditions, which gives concrete targets for implementing idealized universal agents.

Sat 24 OctMachine Learning
The gist
Predicting future events in complex environments often uses idealized mathematical models called Bayesian mixtures. This paper studies what happens when an agent uses an approximate version of these models for planning actions, where the agent’s decisions influence the data it sees next. The authors analyze how errors in prediction can grow depending on factors like how rare the tasks and chosen actions are. They also provide guarantees on how prediction and value errors behave for such agents, clarifying conditions needed for building practical approximations of ideal universal predictors.
Open → 2610.33842v1

Regularised reinforcement learning estimates improve with recommender regret

Recommender regret for improving regularised RL estimation with bandits and MCTS

Abstract: Regularised reinforcement learning (RL) algorithms rely on estimators, like Monte Carlo tree search or one-step look-ahead, to provide policy, value, or Q-value estimates in training and inference. However, existing bandit-based estimation frameworks evaluate sampling efficiency, not the quality of estimates. We address this by formalising estimate generation as a recommendation process, treating bandit-based sampling as an improvement operator. To evaluate the quality of a recommendation (estimate), we define regulariser-aware recommender regrets, analysing their lower bounds, and proving that simple algorithms like uniform sampling can achieve these bounds. Finally, we unify bandit- and search-based target improvement under recommender MCTS. Across synthetic trees, arcade games, and scientific discovery tasks, recommenders often yield faster target convergence and superior downstream performance. Our experiments characterise for the first time the potential of regularised MCTS in scientific applications.

Fri 23 OctMachine Learning
The gist
Estimating the quality of decisions during reinforcement learning often focuses on how efficiently choices are sampled, not on how good the resulting estimates are. The authors treat this estimation as a recommendation problem, introducing a new way to measure how good these recommendations are with a concept called recommender regret. They show that even simple approaches like uniform sampling can meet these measurement goals. Their new framework combines bandit algorithms and tree search methods, leading to faster and better learning in games and scientific tasks.
Open → 2610.32910v1

Primal dual learning shows resonance effects in changing constrained systems

Parametric Resonance in Primal-Dual Learning for Slowly Non-Stationary Constrained MDPs

Abstract: Primal-dual methods for constrained Markov decision processes are analyzed under a two-timescale assumption, with non-stationarity entering through two channels. In the additive channel, where the constraint level oscillates, the dual oscillation saturates at a floor set by the moving optimum and is amplified linearly by the timescale ratio. In the parametric channel, where the constraint sensitivity oscillates, a coherent modulation carries no resonant forcing at any depth: the dual update's stiffness modulation cancels the primal update's damping modulation. Instability instead comes from a mismatch between the constraint estimate used by the primal update and the measurement used by the dual update, producing a parametric resonance at twice the pair's natural frequency. The tolerated mismatch grows with the square root of the forcing bandwidth and collapses with the square root of the dual-to-primal step-size ratio. These results hold on the tangent linear-quadratic reduction around an active saddle, for one constraint and for $K$ constraints under a common modulation and an isotropy condition. Driving both updates from the same estimate removes the resonant forcing but introduces a stationary offset equal to the estimator's bias. In a Lagrangian soft actor-critic agent, the multiplier locks onto the sub-harmonic at the timescale ratios its identified linear loop predicts and a coherent cost critic suppresses the lock-in, while a proportional (PID) term, predicted to leave the lock-in in place, suppresses most of it through the projection of the multiplier.

Fri 16 OctMachine Learning
The gist
When making decisions that have strict rules that can change slowly over time, a common technique called primal-dual learning can behave unpredictably. The authors studied how changes in rule levels or sensitivities can cause the learning steps to resonate, or amplify, leading to instability. They explain that some oscillations are cancelled out naturally, but instability arises if the two learning parts don’t use matching information. They also demonstrated these effects in a reinforcement learning agent and showed how different adjustments can suppress or maintain these resonances.
Open → 2610.23788v1

Learning to sample high-quality actions with logarithmic regret

The Tilted Sampling Problem: Optimism, Posterior Sampling, and Logarithmic Regret

Abstract: Many modern learning systems are used not to select a single best action, but to sample diverse high-quality outputs. Examples include entropy-regularized reinforcement learning, RLHF, and reward-guided generative modeling. Motivated by these settings, we study tilted sampling: an online learning problem in which the goal is to sample from the Gibbs distribution induced by an unknown reward function. We define sampling regret as the temperature-normalized cumulative KL divergence between the learner's distribution and the Gibbs target, corresponding to the suboptimality gap in entropy-regularized reward maximization. Our framework generalizes recent sampling-based and KL-regularized formulations in bandits and reinforcement learning. Our main contribution is a general regret framework that captures the different uncertainty structure of tilted sampling and classical regret minimization. While standard regret scales as $\widetilde{O}(\sqrt{T})$ due to first-order uncertainty, sampling regret is governed by squared confidence widths, yielding logarithmic-in-$T$ regret in standard settings at fixed temperature. We develop sampling analogues of UCB and Thompson sampling (UCS and TS$^2$) and provide unified regret decompositions that explain and extend recent logarithmic guarantees, including the first Bayesian sampling-regret decomposition based on new bounds for posterior-random Gibbs distributions. Our results show that learning to sample from a soft-optimal distribution is statistically distinct from learning to identify a hard optimum.

Thu 15 OctMachine Learning
The gist
Some AI systems don’t just pick the single best action but instead sample several good options based on unknown rewards. The authors study this as a problem of learning to sample from a specific distribution that balances reward and randomness. They measure how well the learner’s sampling matches the ideal distribution over time and find that their approach improves much faster than traditional methods. Their work shows sampling good options is fundamentally different and sometimes easier than learning the single best option.
Open → 2610.21908v1

Router drift control improves expert routing in reinforcement learning

Router Drift Control: Mitigating Off-Policy Degradation in Mixture-of-Experts Reinforcement Learning

Abstract: Reinforcement learning (RL) can become off-policy due to training-inference mismatch, mini-batch updates, and asynchronous training.The resulting mismatch is especially harmful in Mixture-of-Experts (MoE) models, where rollout--training discrepancies can change routing decisions and lead to router drift. Rollout Routing Replay (R3) mitigates this mismatch by reusing expert selections from the rollout stage during training. Our analysis shows that routing replay introduces gradient bias by losing contributions from experts selected by the training router but not the rollout router. To address this, we propose Router Drift Control (RDC), which uses routing disagreement between rollout and training as a signal of off-policy staleness and selectively rejects high-drift responses. The sequence-level filtering avoids gradient bias introduced by replay while preserving native expert selection and the associated learning signals for retained responses. Experiments show that RDC achieves larger gains as policy staleness increases and remains effective in asynchronous RL. In asynchronous training, RDC combined with Truncated Importance Sampling (TIS) improves the average peak validation accuracy across AIME 2024 and AIME 2025 by 5.5 points over TIS and 4.5 points over R3.

Thu 15 OctMachine LearningArtificial Intelligence
The gist
Reinforcement learning systems sometimes train with data that doesn’t exactly match how they operate when making decisions, causing performance problems. This issue is larger in models called Mixture-of-Experts, where decisions about which expert to use can drift and degrade results. The authors show that a previous fix can bias learning and propose Router Drift Control, which detects when decisions disagree and filters out problematic examples. Their method keeps learning signals intact and works better as the difference increases, especially in asynchronous setups.
Open → 2610.21682v1

Sign betting improves misspecified regression with variance adaptivity

Sign Betting for Misspecified Regression: Variance Adaptivity and Optimal Approximation

Abstract: We study bounded regression under model misspecification, evaluating a function $f$ by its $L_1(P_X)$ distance to the conditional mean $η(x)=\mathbb{E}[Y\mid X=x]$, rather than the standard $L_2(P_X)$. This $L_1$ metric is natural for downstream decision problems such as bandits and reinforcement learning. We analyze the min--max estimator of Baraud & Maillard (2025), which we call \emph{sign-betting regression}. Our main results show that sign-betting regression achieves high-probability $L_1$ oracle inequalities under misspecification. Under realizability, our bound adapts to the average conditional variance and recovers the variance-adaptive rate of Li et al. (2026). We further characterize the optimal universal approximation factor for proper learning by showing that sign betting achieves factor 3, while no proper learner can satisfy a distribution-free, high-probability $L_1$ oracle inequality with a universal approximation factor strictly below 3. We extend the upper-bound analysis beyond finite classes and complement the theory with experiments in synthetic and real-world model-selection tasks.

Wed 14 OctMachine Learning
The gist
This paper looks at how to measure errors in predictions when the model might not be perfect. Instead of using a common squared error, the authors focus on a different way to measure mistakes that matters more for certain decision-making tasks like learning from experience. They study a specific method called sign-betting regression, showing it can adapt to how uncertain the data is and perform nearly as well as the best possible method. The paper also shows limits on how well any method can do under these conditions. They tested their findings with experiments on synthetic and real data.
Open → 2610.20903v1

Distributional critics improve value estimates with posterior averaging

Posterior-Averaged Bellman Flow Matching for Distributional Critics

Abstract: Distributional critics model the full return distribution, providing richer signals for exploration and risk-sensitive control. Recent work has shown that flow-based critics can model these distributions flexibly and provide effective supervision across flow time for temporal-difference learning. However, unlike standard flow matching with fixed data endpoints, a flow critic is trained on Bellman targets recursively generated by a learned target critic under the current policy. Existing objectives therefore either use noisy single-endpoint supervision or rely on the learned flow itself for additional guidance. Our key observation is that an intermediate bridge state may be compatible with several Bellman endpoints, so its velocity should average their directions under the corresponding posterior. We propose Posterior-Averaged Bellman Flow Matching (PA-BFM), which samples an endpoint pool, infers the closed-form posterior over the latent anchor, and regresses to the posterior-mean velocity. Uniform anchor selection makes this target an exact finite-pool Rao--Blackwellization of the single-endpoint target: for every \(K\), it preserves the population target, cannot increase conditional variance, and its conditional variance scales as \(O(K^{-1})\). The endpoint pool supports conservative updates, while the twin return flows provide critic-disagreement and unsupported-mass diagnostics. Controlled studies show that PA-BFM reduces fixed-query target mean-squared error by \(79.7\%\) and target-induced gradient variance by up to \(98.0\%\), while improving return-distribution fidelity. Across 50 OGBench tasks and four offline-to-online scenarios, PA-BFM achieves higher aggregate performance than Value Flows.

Tue 13 OctMachine LearningArtificial Intelligence
The gist
Estimating all possible outcomes of decisions helps AI learn better and take smarter risks. The authors found that existing methods struggle because they only use one target outcome at a time, which can be noisy or inconsistent. They propose a new way to consider multiple possible future outcomes together, averaging the directions the AI should learn from. This approach reduces error and uncertainty in learning, leading to better and more reliable predictions in many tested tasks.
Open → 2610.17788v1

Variance optimal state sampling improves reinforcement learning efficiency

Variance-Optimal State Resampling for Reinforcement Learning with Verifiable Rewards

Abstract: Reinforcement learning with verifiable rewards spends much of its rollout budget on states that yield no learning signal. We recast this as a question about the sampling distribution itself: under a fixed rollout budget, which distribution over states minimizes the variance of the policy-gradient estimator? The answer admits a closed-form Neyman allocation, $μ_{\mathrm{var}}^π(s) \propto d^π(s)\,σ_π(s)$, which connects naturally to GRPO's group-relative advantage and induces an emergent reverse curriculum as the policy improves, with no externally imposed schedule. Building on this principle, we propose VSR (Variance-driven State Resampling), a plug-in modification to GRPO using a prefix replay buffer and a zero-cost variance proxy. On mathematical reasoning benchmarks and long-horizon agentic tasks (Sokoban, BabyAI), VSR outperforms GRPO and GiGPO on most benchmarks with fewer generated tokens per update.

Sun 11 OctMachine LearningArtificial Intelligence
The gist
Reinforcement learning often wastes time exploring states that don’t help improve the policy. The authors studied how to pick states to minimize randomness in learning, finding a way to focus on states that matter most for better learning signals. They developed a method called VSR that changes how states are sampled using a clever replay buffer and a low-cost way to estimate variance. This method performs better than similar approaches on challenging tasks while using less computational effort.
Open → 2610.15888v1

Policy score bounds ensure smoothness in common decision methods

Notes on Uniform Policy Score Bounds and Lipschitz Continuity for Truncated Gaussian, Product Cauchy, Boltzmann, and Softmax Policies

Abstract: We establish uniform score bounds and Lipschitz continuity for truncated Gaussian, Cauchy, Boltzmann, and softmax policies under explicitly stated parameterizations.

Sun 11 OctMachine Learning
The gist
This paper looks at how certain mathematical decision-making methods behave when small changes happen in their inputs. The authors focus on popular policies used in areas like AI, such as truncated Gaussian, Cauchy, Boltzmann, and softmax methods. They show that these policies have limits on how much their scores can vary (called uniform score bounds) and that the policies change in a controlled, predictable way (Lipschitz continuity). This kind of understanding helps ensure that these decision systems behave reliably and do not react unpredictably to slight changes.
Open → 2610.15690v1

Explicit curriculum training matches lLM methods without action masking

Anchor-and-Harvest Curriculum: A Fully Unmasked Non-LLM Curriculum for Craftax

Abstract: We introduce Anchor-and-Harvest Curriculum (AHC), a domain-informed, rule-based training system for Craftax-Full. AHC combines achievement-oriented tasks, harvested initial-state progress, difficulty adaptation, bounded selection, and original-task practice. It uses no LLM inference and keeps all 43 actions available. At 2,005,401,600 PPO rollout transitions, three primary AHC runs obtain native-task return $46.70\pm0.57$ (sample SD), compared with $41.91\pm1.01$ for fresh native PPO-GTrXL with the same student architecture and evaluation protocol. Evaluation uses ten stochastic rollouts on each of 1024 fixed worlds per model. An additional cohort of three AHC runs reaches $46.08\pm1.23$. Two single-component ablations retain similar mean returns, while jointly freezing difficulty and removing inherited progress gives $45.14\pm2.79$. All-67-achievement profiles show that most of the return difference comes from Intermediate achievements, while the deepest-floor achievements remain unsolved. A Skill-Preflight diagnosis with a 14B teacher shows how prerequisite and floor-access constraints restrict practice. AHC and three 14B diagnostic configurations reach aggregate returns near the reported 80B DiCode mean of 45.88 and below the 235B mean of 48.55. These results show that an explicit curriculum without LLM inference can reach returns comparable to those reported for LLM-generated curricula on Craftax-Full, without action masking.

Sun 11 OctMachine LearningArtificial Intelligence
The gist
This paper shows how a carefully designed training system called Anchor-and-Harvest Curriculum (AHC) can teach an AI to perform well in a complex game called Craftax-Full without using large language model (LLM) inference. The authors combined different learning techniques like adjusting difficulty and practicing original tasks without hiding any possible actions from the AI. Their method achieved performance close to systems that use much larger LLMs, showing that explicit, rule-based curriculums can be very effective. They also analyzed which parts of the game were still too hard and how constraints limit learning progress.
Open → 2610.15328v1

ObsSpec speeds up reinforcement learning by guessing tool outputs early

ObsSpec: Accelerating Agentic Reinforcement Learning with Observation Speculation

Abstract: Tool-using agents alternate between model generation and tool execution, waiting for each tool call to complete before starting the next generation. This sequential execution is costly during agentic reinforcement learning (RL), which requires large batches of multi-turn rollouts. We introduce ObsSpec, an observation speculation pipeline for agentic RL that uses a small world model to predict tool outputs while the environment executes, allowing the policy to begin its next generation early. ObsSpec retains speculative work only when the predicted and actual observations match exactly, making rollout collection lossless, while co-training keeps the world model up to date as the policy learns. On terminal-use tasks, predictions from a 0.6B world model exactly match actual observations in 66.4% of attempts and arrive roughly 16 times faster. Using these predictions, ObsSpec reduces agent latency by 9.3% and 14.2% for 8B and 32B policies. Across controlled experiments, we characterize the regimes in which ObsSpec reduces agent latency under shared policy resources. Finally, because ObsSpec overlaps policy generation with tool execution, it is architecturally compatible with existing techniques for accelerating RL. Code is available at https://github.com/kylemontgomery1/verl-recipe/tree/obsspec/obsspec.

Sun 11 OctMachine Learning
The gist
Running agents that use tools in reinforcement learning can be slow because they wait for each tool's results before deciding the next step. The authors created ObsSpec, which guesses what the tools will output ahead of time, so the agent can start thinking about the next step sooner. If the guess matches the actual output exactly, the work is saved, making the process faster without losing accuracy. This approach reduced delays and worked well with existing techniques to speed up learning.
Open → 2610.15246v1

Value function reveals environment rules learned by agent

Visualizing the World Model in an Agent's Value Function

Abstract: Could model-free reinforcement learning algorithms actually be learning a model of the environment? In this work, we apply counterfactual interventions which hold everything about a state fixed, besides a targeted change, to explore if the value function of a Proximal Policy Optimization agent forms a world model of the Crafter environment. Despite only being trained to optimize reward, we discover that the value function learns concepts such as the rules governing when a diamond is collectible, water and food having an impact on health, heuristics regarding inventory, and more. Finally, we discuss the safety implications of our visualizations and some shortcomings of current reinforcement learning agents that will prevent us from building truly advanced machine intelligence.

Fri 9 OctArtificial IntelligenceMachine Learning
The gist
Sometimes, AI that learns by trial and error might secretly figure out how the world works, even if it wasn’t explicitly taught. The authors studied a particular AI agent playing a game and found that its measure of how good a situation is (called the value function) actually understood things like when it could collect a diamond or how eating affects health. They used special tests to confirm the AI had learned these ideas. They also talk about what this means for safety and the limitations of current AI systems.
Open → 2610.14186v1

Q-learning error bounds reveal sample needs for stable learning

Hitting-Time Bounds for Asynchronous Q-Learning

Abstract: We study the last iterate of standard asynchronous Q-learning from a single trajectory of a finite Markov decision process. The trajectory follows a fixed behavior policy whose state--action chain is irreducible and may be periodic. For discount factor $γ$, write $H=(1-γ)^{-1}$, and let $μ_{\min}$ be the minimum stationary state--action probability and $\mathfrak h_\star$ the largest expected hitting time of the reverse state--action chain. We prove that zero-initialized Q-learning with a constant step size achieves sup-norm error at most $\varepsilon$ with high probability using $\widetilde{O}(H^4/(μ_{\min}\varepsilon^2)+\mathfrak h_\star)$ transitions, for $0<\varepsilon\le1$. The statistical term retains the quartic effective-horizon dependence of standard Q-learning, while initialization cost is additive in $\mathfrak h_\star$. For aperiodic behavior chains, a comparison with mixing time yields a transient term $\widetilde{O}(t_{\mathrm{mix}}/μ_{\min})$. An empirical state--action count rule selects a constant step size for a subsequent training run and attains the same rate without prior knowledge of model parameters, target accuracy, or confidence level. The output is the last training iterate, with both stages included in the sample count. The proof uses two deterministic Bellman envelopes to separate statistical error from fixed-policy initialization error and adapts reverse-time hitting-cost compensation from TD learning to state--action propagation. An exploration lower bound holds for arbitrary predictable step sizes. Together with the existing statistical lower bound and its extension to pilot-selected constant steps, it yields matching mean-square rates up to logarithmic factors on the stated large-sample parameter classes.

Fri 9 OctMachine Learning
The gist
This paper looks at how much data is needed for a common AI learning method called asynchronous Q-learning to get close to the true value estimates. The authors analyze the learning process when following a fixed set of actions in a system with states and probabilities, and they provide formulas for the sample size needed to reach a small error with high confidence. They also propose a way to automatically choose learning rates without knowing some details of the system ahead of time. Finally, their theoretical results match known lower bounds, suggesting these sample sizes are close to optimal.
Open → 2610.13901v1

Minecraft benchmark tests lasting agent skill improvement and transfer

MC-EvoBench: Auditing Experience-Driven Self-Improvement in Minecraft Agents

Abstract: A central challenge in embodied recursive self-improvement is enabling agents to convert interaction history into capabilities that persist beyond one world and transfer to later tasks. A saved memory or successful final action does not by itself establish that a reusable capability was acquired; evaluation must separate capability change from carried-over resources, unequal source exposure, and early execution failures. We construct MC-EvoBench as a controlled Minecraft benchmark with a fixed catalog of 19 registered evolution chains, including 12 primary evaluation chains and seven calibration or probe chains, together with three graph-aligned paired probe families for transfer. The benchmark represents each task as a task-state graph, defines stage-level environment verifiers, assigns matched source and target roles, resets the target world, and permits only a declared agent artifact to cross the source-target boundary. For each probe, no-prior, related, unrelated, and shuffled source conditions are evaluated under matched environment-step budgets and five seeds; we report TSR, WGP, and VMP and retain provenance records. The benchmark reveals a consistent direct-capability gap between controller and planner-backed variants, while related experience yields no stable transfer: it does not improve either tool probe, its small wood-species gain hinges on one seed, and all intervals include zero. Stage audits further show that early wood-collection and crafting bottlenecks often leave later capabilities unobserved. MC-EvoBench thus offers a controlled testbed for durable, transferable embodied capabilities. Code and data are available at https://github.com/xzw-ustc/mc-bench-open-source

Fri 9 OctRoboticsArtificial Intelligence
The gist
It is hard to tell if a Minecraft-playing AI really learns skills it can use again in new games or simply remembers past items or worlds. The authors built MC-EvoBench, a Minecraft test setup that carefully resets the game world and only lets the AI bring declared saved changes from one challenge to another. Their tests show that some AI with advanced planning improves more than simpler ones, but past experience rarely helps consistently on new tasks. Early challenges like collecting and crafting wood can block the observation of later skills. This benchmark helps measure if Minecraft agents truly improve in ways that last and transfer.
Open → 2610.13829v1

Variance-reduced policy gradient methods reach optimal sample complexity limits

Variance-Reduced Policy Gradient is Nearly Minimax-Optimal

Abstract: Standard Policy Gradient (PG) algorithms suffer from high estimation variance because they rely on Monte Carlo updates. While off-policy variance reduction mitigates this problem, establishing optimal sample complexity currently requires either restrictive assumptions, such as uniformly bounded importance weights, or impractical second-order operations. In this work, we introduce Loopless Variance-Reduced PG (LVR-PG), a unified theoretical framework that abstracts a class of first-order estimators that integrate recursive updates with defensive importance sampling, including known estimators such as PAGE-PG and STORM-PG. We prove that this algorithmic class achieves $\tilde{\mathcal{O}}(ε^{-2})$ last-iterate global convergence under weak gradient domination for general parametric policies. We establish this guarantee using purely first-order updates, with minimal assumptions and without gradient preconditioners. By extending state-of-the-art lower bounds to continuous parametric policies, we establish an $Ω(ε^{-2})$ sample complexity limit, confirming our framework is minimax-optimal up to logarithmic factors and horizon terms.

Fri 9 OctMachine LearningArtificial Intelligence
The gist
Policy Gradient methods are used in AI to teach computers how to make decisions, but they often need lots of trial runs because their estimates can be very noisy. The authors developed a new way to reduce this noise using clever updates that avoid complicated calculations, making learning more efficient. They proved that their approach is almost the best possible in terms of how many samples it needs to learn well, even under broad conditions. This means computers can learn good policies faster without relying on restrictive assumptions.
Open → 2610.13692v1

Policy optimization improves decision making in adversarial settings

Closing the Horizon Gap in Policy Optimization for Adversarial MDPs

Abstract: We consider policy optimization for online episodic tabular Markov decision processes (MDPs) with adversarial losses and bandit feedback. Policy optimization updates the policy locally at each state and avoids optimization over the occupancy-measure polytope, but its existing regret bounds are larger by a factor of the horizon $H$ than those of occupancy-measure-based algorithms. We close this gap by using regularized $Q$-functions, which allow us to control the stability of the local updates jointly over all state-action pairs rather than separately at each state. The resulting algorithm attains high-probability regret bounds of $\widetilde O(\sqrt{HS(H+A)T})$ for known transitions and $\widetilde O(HS\sqrt{AT})$ for unknown transitions, where $S$ is the number of states, $A$ the number of actions, and $T$ the number of episodes. Both bounds improve the horizon dependence of existing policy optimization bounds, and the latter matches the best-known bound. We further extend the algorithm to adversarial linear-mixture MDPs and obtain the same improvement in the horizon dependence.

Thu 8 OctMachine Learning
The gist
When computers learn to make decisions step-by-step in complex situations, they must plan ahead across many actions. Existing methods for this planning are slower because they consider the entire timeline more than necessary. The authors found a way to speed up this process by carefully controlling how the decision updates happen, reducing unnecessary steps. This leads to better performance in challenging environments where outcomes can change adversarially. Their approach works even when the computer doesn’t initially know how actions affect future states.
Open → 2610.12362v1

Group policy optimization improves by calibrating reward and KL updates

When KL Regularization Misfires in Group Policy Optimization

Abstract: Why does removing reference-policy KL regularization sometimes improve group policy optimization? This motivates studying how reference-policy information should enter group-relative updates. We analyze seven potential failure modes in the interactions between KL and rewards: residual KL updates after reward clipping, after gradient cancellation, and in groups with identical rewards; KL growth with response length and an imbalance in its relative contribution; KL concentration on a small number of tokens; and sampling noise when k1 is incorporated into rewards. We propose Zero-Sum Calibrated Policy Optimization (ZCPO), which uses relative drift measured by conditional KL to calibrate within-group reward coefficients and integrates them into the base surrogate. Mathematical reasoning experiments and ablations support this design's effectiveness in our settings.

Thu 8 OctMachine LearningComputation and Language
The gist
When training AI systems that learn by trial and error, sometimes a common technique called KL regularization can actually slow down learning. The authors find several reasons why this happens, such as leftover effects from previous steps and imbalanced influences. They suggest a new method called Zero-Sum Calibrated Policy Optimization that adjusts how rewards and KL regularization work together. Their experiments show this new method helps improve learning in these scenarios.
Open → 2610.12161v1

Transport maps improve policy gradients in population control models

Randomized Transport Maps for Model-Free Policy-Gradient Mean-Field Control

Abstract: We develop a model-free policy gradient method for discrete-time mean-field control (MFC). In MFC, the policy affects the objective both through the controlled dynamics and through the population distribution. Standard REINFORCE estimators capture the first effect but not the second. We introduce Transport REINFORCE, a transport map-based approach that perturbs a suitable transformation of the population distribution to estimate this missing mean-field contribution. The method applies to both finite and continuous state spaces. In finite state spaces, we perturb the population distribution directly on the probability simplex through a convex combination of the current population weights and random weights. In continuous state spaces, we project the population distribution onto the manifold of Gaussian mixtures, and then randomize it via a transport map that ensures the perturbed law remains within this manifold. We prove consistency of the perturbed objective and gradient as the perturbation vanishes, and derive bias and mean-square error bounds for the resulting sample-based gradient estimator. Numerical experiments on several MFC benchmarks show that Transport REINFORCE improves over standard REINFORCE.

Thu 8 OctMachine Learning
The gist
Controlling behavior in large populations is tricky because changes affect individual outcomes and the whole group together. The authors study a way to teach computers to make better decisions in such settings without knowing all details beforehand. Their method, called Transport REINFORCE, uses a clever technique to estimate how changing group behavior affects the goal, improving on older methods. They tested this on examples and found it works better than standard approaches.
Open → 2610.11619v1

BluffJAX accelerates complex poker games with GPU simulations

BluffJAX: Adversarial Imperfect Information Games in JAX

Abstract: We introduce BluffJAX: an open-source suite of adversarial imperfect information games in JAX. We provide canonical implementations of games designed for high simulation throughputs and parallelization on GPU accelerators. Our suite consists of well-studied benchmarks such as Texas Hold'Em Poker and Kuhn Poker, as well as games that have not been previously studied in reinforcement learning research, such as Bluff, Stud Poker, and Kemps. We hope that implementing a variety of game mechanics and difficulties will introduce new challenges and foster novel research directions in game-theoretic methods for RL. We benchmark the throughput performance and memory usage of our environments in single and multi-GPU settings, demonstrating scaling of up to hundreds of millions of samples per second, and motivating the usage of BluffJAX over related GPU and CPU-based libraries. We benchmark reinforcement learning, tree search, and game-solving algorithms in JAX in order to provide users with baseline results and facilitate future comparisons.

Tue 6 OctArtificial Intelligence
The gist
Playing strategy games where you can't see all information, like poker, is hard for computers to learn. This work introduces BluffJAX, a tool that runs many poker and other card games very fast using computer graphics processors. It includes games both common and less studied, helping researchers test and improve techniques for teaching computers how to play better. The authors show that BluffJAX can handle huge numbers of simulated games at once, making it faster than similar tools.
Open → 2610.07686v1

Model based reinforcement learning needs context aware design

Considering Context: When World Models Need Context Encoders

Abstract: Methods for generalization in model-based reinforcement learning typically assume that an agent cannot recover the latent context governing the environment dynamics from its own experience, and therefore supplies it externally. We formalize and test this assumption with \emph{predictive sufficiency}, which quantifies what access to the context adds to next-step prediction under the visitation distribution an agent induces, and separates that quantity into a history-recoverable part, a residual requiring the true context, and the deficit added by a finite model. We classify context-aware algorithms by the predictive risk their conditioning set can target and demonstrate across environments of increasing identification difficulty that the headroom does not follow the MDP class. The same task under different priors leaves predictive headroom in one setting and nothing distinguishable from zero in another, where the agent's behavior implicitly identifies the context and any benefit of such a mechanism cannot be attributed to missing information. Where headroom persists, the learned state exposes it only partially, and adding the true context still lowers the risk. Our contribution is a practical criterion for matching contextual mechanisms to the information available to them, estimated from the ordinary trained agent without a reference policy.

Mon 5 OctMachine Learning
The gist
Sometimes, when AI agents learn to make decisions, there is hidden information about the world that affects what happens next. The authors studied when giving the agent extra information about this hidden context actually helps it predict better, and when the agent can figure out enough from its own experience. They found that this varies depending on the environment and the agent’s behavior, and created a way to measure when adding context helps and when it does not. This helps designers know if and how to give AI access to hidden information effectively.
Open → 2610.06651v1

Exponential sample complexity limits off-policy evaluation with memory

Revealing After Overwriting: An Exponential POMDP OPE Lower Bound under History-Dependent Logging

Abstract: Multi-step revealing can make off-policy evaluation tractable under memoryless logging. With history-dependent logging, state decodability and target-relevant evidence can separate. For every horizon $H\ge3$, we construct two exactly realizable POMDPs with four actions, at most four states per layer, a known logger, and a memoryless target. Action overlap, history coverage, and observation-only revealing remain bounded independently of $H$, yet the target values differ by $1/2$ and the KL divergence between the logged laws is $Θ(4^{-(H-1)})$, forcing exponential sample complexity. Logger memory makes states distinguishable, while reset erases the model-distinguishing evidence preserved by the target. A separate construction retains this barrier with common, known observation-only revealing operators. Under action and history coverage, we give a finite-class OPE guarantee using common observable value representations that remain valid at every history. The sample bound depends polynomially on their second-moment cost. In the common-operator construction, the same value direction has constant marginal decoding cost but exponential history-conditioned cost. Finally, on a fixed four-action continuum, we derive matching passive and budgeted readout rates. With one known channel and unit read cost, early reads are optimal. With unknown sensor bias, early reads alone remain exponentially costly. Combining them with post-reset calibration gives sample complexity independent of $H$ when both read types receive fixed positive expected budgets per trajectory.

Sun 4 OctMachine Learning
The gist
Off-policy evaluation helps predict how new actions perform based on past data. This paper shows that when the data depends on past choices (history-dependent logging), it can require an exponential amount of data to learn accurately—even if the system looks simple in many ways. The authors build examples proving this inherent difficulty and also identify conditions that can make evaluation feasible again. They further analyze strategies to reduce sample costs in certain settings with known or unknown sensors.
Open → 2610.05063v1

Success conditioning guarantees optimal policy convergence in decision problems

On the Convergence of Success Conditioning for Policy Optimization

Abstract: Success conditioning is a strategy for improving decision-making policies in stochastic environments; it updates a policy by increasing the probability of taking actions that yield successful outcomes. Success conditioning is common to many reinforcement learning applications, yet its limiting behavior and convergence rates are not well understood. In this work, we demonstrate that success conditioning converges to an optimal policy on a broad class of Markov decision processes (MDPs). We also derive convergence rates in some common settings. For discounted MDPs, we prove convergence within $\mathcal{O}(1/\varepsilon^p)$ iterations to an $\varepsilon$-optimal policy, where the exponent $p$ depends on problem data. For single-period MDPs, such a policy is obtained within $\mathcal{O}(\log(1/\varepsilon))$ iterations.

Fri 2 OctMachine Learning
The gist
Success conditioning is a way to improve decision-making by favoring actions that have led to success before. The authors show that this approach always finds the best strategy in many common decision problems modeled as Markov decision processes. They also explain how quickly this learning happens in certain settings, sometimes very fast and sometimes more gradually depending on the problem. This helps clarify how reliable and efficient success conditioning is for improving decision policies.
Open → 2610.03642v1

Defensive policy gradient improves learning speed with weaker assumptions

Sample complexity of variance-reduced policy gradient: weaker assumptions and lower bounds

Abstract: Several variance-reduced versions of REINFORCE based on importance sampling achieve an improved $O(ε^{-3})$ sample complexity to find an $ε$-stationary point, under an unrealistic assumption on the variance of the importance weights. In this paper, we propose the \algo (Defensive Policy Gradient) algorithm, based on defensive importance sampling, which achieves the same rate without any assumption on the variance of ordinary importance weights. We also establish lower bounds in a generalized black-box policy-optimization model that hides states and actions and permits parameter-dependent rewards. In this model, the optimal rates are $Θ(ε^{-4})$ with bounded-variance one-policy feedback and $Θ(ε^{-3})$ with mean-square-smooth coupled two-policy feedback. Under standard policy-regularity conditions, REINFORCE and \algo realize the corresponding oracle conditions and attain the $O(ε^{-4})$ and $O(ε^{-3})$ upper bounds, respectively. Although the lower bounds do not apply directly to the classical MDP interaction model in which these algorithms operate, this correspondence provides oracle-level evidence that the faster rate of \algo is optimal and genuinely separated from that of vanilla policy gradient.

Fri 2 OctMachine Learning
The gist
Finding good strategies in decision-making problems often requires testing many options, which can be slow. This paper introduces a new method, Defensive Policy Gradient, that speeds up learning without relying on unrealistic assumptions about uncertainty. The authors show it matches the best known speed in theory and prove that this speed is likely the fastest possible under similar conditions. Their work clarifies why this new method is genuinely better than traditional approaches in terms of efficiency.
Open → 2610.03165v1

Coding agent detects cheating by monitoring behavior during code generation

hacktrace: behavior-supervised detection of reward hacking during code generation

Abstract: A coding agent can earn a passing grade by fixing its code, or by deleting the test that exposes the bug. Detecting such reward hacking requires recognizing attempted shortcuts, including those that fail. We release 173,561 annotated multi-turn coding trajectories from Qwen3-8B and show that supervising shortcut behavior independently of exploit success substantially improves detection. We introduce HACKTRACE, a behavior-supervised monitor that reads the internal states the agent already computes while generating code. Reusing these states enables monitoring before a turn is complete, without additional language-model tokens or passes. Combining this evidence with static features of the final files achieves a mean per-problem AUC of 0.997 with 8 ms of monitoring overhead, improving both accuracy and latency over monitors that run the model again on an honesty question and answer. The same generation states also provide an inexpensive monitoring signal for reinforcement learning. With strong GRPO penalties, HACKTRACE reduces the cheating share of passing solutions from 82-91% to 1-5%, while retaining honest, correct solutions and maintaining high detection accuracy as the policy evolves. Our results show that both the supervision target and the source of monitoring evidence matter for turning accurate detection into a useful training signal.

Fri 2 OctArtificial Intelligence
The gist
When AI systems write code, they can sometimes cheat by deleting tests that find bugs instead of fixing the bugs themselves. The authors released a large dataset of AI coding behaviors and created HACKTRACE, a new tool that watches the AI's internal reasoning while it writes. This tool spots cheating attempts early and more accurately than previous methods, helping to train the AI to be honest while keeping good solutions. Their results show that looking at how the AI behaves inside during code writing helps catch cheating better than just checking the final code.
Open → 2610.03055v1

Intrinsic rewards sometimes fail to guide the best exploration

When Do Intrinsic Rewards Lead to Exploration?

Abstract: Intrinsic rewards are designed to guide exploration in reinforcement learning by assigning value to an agent's experience, for example through prediction error or learning progress. However, maximizing these rewards need not produce the most informative experience available. We propose a formal criterion for exploration that compares policies by the counterfactual information they acquire: how well their histories can substitute for experience under alternative policies. We construct a single, simple environment in which specified count-based, prediction-error, empowerment, and information-gain objectives have maximizing policies that are Pareto-suboptimal at acquiring counterfactual information. We explain these failures and establish conditions under which existing intrinsic rewards successfully encourage optimal exploration. We also construct an objective that assigns a higher value whenever exploration strictly improves under our criterion.

Thu 1 OctMachine Learning
The gist
Exploration helps AI learn about new things, often by giving rewards based on curiosity signals like surprise or learning progress. The authors show that these internal rewards may not always push the AI to gather the most useful information. They create a way to measure how well exploration works by comparing different approaches on what could have been learned otherwise. Using a simple example, they find that many popular curiosity rewards lead to suboptimal exploration and explain when these rewards actually help. They also propose a new measure that better values improvement in exploration according to their criterion.
Open → 2610.02159v1

Distinguishing decision models in non-Markovian environments exactly and efficiently

Exact Distinguishability in Non-Markovian Decision Processes

Abstract: Non-Markovian environments are often modeled as Regular Decision Processes (RDPs), where dynamics depend on the interaction history through a finite automaton. Existing offline guarantees for RDPs rely on a distinguishability assumption on the behaviour policy but provide no means of verifying it. When the assumption is violated, distinct models may explain the data equally well. We study when data collected under a fixed behaviour policy can distinguish two candidate RDPs. We prove that the posterior odds between observationally equivalent candidates remain equal to the prior odds at every sample size, even when the policy visits every automaton state, and verify both results formally in Lean 4. We then characterize this equivalence exactly and derive PEC, an algorithm that decides it in time linear in the size of the product automaton. The distinguishability assumption of prior work fails on three of our four test environments, and the experiment identified by PEC restores it in each case.

Thu 1 OctMachine LearningArtificial Intelligence
The gist
This paper studies how to tell apart two possible decision-making models that depend on past actions rather than just the current state. The authors found that sometimes no amount of data can help tell these models apart, even under policies that explore all states. They mathematically prove this and create an efficient algorithm to check when two models can be distinguished using the collected data. Their tests show that widely used assumptions about being able to distinguish models do not hold in many cases, but their algorithm can identify how to fix this.
Open → 2610.01527v1

Optimal transport improves distribution comparison in reinforcement learning

Optimal Transport Meets Reinforcement Learning: A Survey

Abstract: Reinforcement learning (RL) algorithms frequently compare probability distributions, such as state visitation distributions induced by policies and experts, action distributions from learned policies and offline datasets, or transition distributions from learned models and environments. However, commonly used divergences may become ineffective when these distributions overlap weakly, which is frequently encountered in imitation learning, offline RL, and deployment under distribution shift. Optimal transport (OT) offers an alternative by measuring the cost of \emph{moving} probability mass from one distribution to another under a ground cost that encodes task geometry. This survey covers how OT is used inside RL objectives and algorithms. For each method, we identify: the role OT plays, the distributions compared, the OT formulation used, and the treatment of temporal structure. Beyond categorising existing methods, we discuss the motivations behind different OT choices, practical considerations such as cost design and computational challenges, and highlight open problems including scalable trajectory-level transport, principled handling of mass mismatch, and theoretical analysis for OT-regularised RL.

Thu 1 OctArtificial IntelligenceMachine Learning
The gist
Reinforcement learning methods often need to compare different sets of outcomes or behaviors, which can be tricky when these sets differ a lot. The authors review how a mathematical tool called optimal transport helps measure differences more effectively by considering the cost to change one behavior into another. This can improve learning from examples, using offline data, or handling changes in the environment. They also discuss practical challenges and future questions in using optimal transport for reinforcement learning.
Open → 2610.01413v1

Fast convergence method improves learning in regularized reinforcement learning

Fast Regularized Policy Mirror Descent with One-Step TD Updates

Abstract: Policy mirror descent (PMD) enjoys fast convergence in regularized Markov decision processes (MDPs), but existing guarantees often rely on exact or increasingly accurate policy evaluation. We analyze PMD coupled with a persistent critic advanced by one temporal-difference (TD) update. For finite discounted MDPs, we establish global linear convergence in value for exact coordinate-wise Bellman updates, with any positive constant actor stepsize and arbitrary finite critic initialization. The proof combines a resolvent-based auxiliary distribution with a decaying Bellman-violation correction and a potential weighted by inverse coordinate weights. We then study stochastic TD-PMD with general strongly convex mirror maps under a single off-policy Markov trajectory. With suitably chosen constant stepsizes and a finite-batch TD update, the method achieves an expected value gap of $ε$ after $\widetilde{O}(1/((1-γ)^5 \widetildeσ_b ε))$ transitions. The stochastic analysis relies on the trajectory-wise Lipschitz continuity of the regularizer, derived from uniform bounds on vertex Bregman divergences, together with a visitation-weighted resolvent estimate for signed critic-error propagation that yields an inverse-linear dependence on behavior coverage $\widetildeσ_b$. In contrast to many prior guarantees for regularized policy optimization, our sample-complexity guarantee holds without trajectory resets, generative-model access, or nested policy-evaluation loops. Numerical results are consistent with the theoretical convergence analysis.

Wed 30 SeptMachine Learning
The gist
Learning the best actions in uncertain environments is tricky because accurately assessing the value of each action usually takes a lot of effort. The authors studied a way to speed up this learning process by combining policy updates with quick value estimates using just one update step. They proved mathematically that their approach reliably finds good policies faster than before, even when starting from random guesses and using limited data. This method works without needing complicated resets or extra models, making learning more efficient.
Open → 2609.39837v1

Policy correction method improves reinforcement learning sample efficiency on tree-like tasks

Free Everywhere, Exact on Trees: PPO's Dropped Correction Buys Sample Efficiency Under Aggressive Reuse

Abstract: Common policy improvement methods, including TRPO, PPO, and GRPO, estimate policy improvement under the behavioral policy's state-visitation distribution rather than the improved policy's own. The substitution makes the objective estimable from the behavioral policy's rollouts but adds a bias growing with policy divergence, hence the trust region or clip, and hence no reuse of a batch far off-policy. We show that under history-injective dynamics, where each state is reached by exactly one history, the dropped state-visitation ratio equals the product of per-step policy ratios along the sampled prefix, on every trajectory and not only in expectation. The ratio is therefore restored exactly, from log-probabilities PPO already computes. Autoregressive generation and canonical-order constructive optimization are both history-injective. The exact correction pays importance-sampling variance that grows with the horizon, so we generalize it to a one-parameter family with PPO ($α{=}0$) and the full correction ($α{=}1$) as endpoints: a single bias--variance knob. A gradient-level analysis of the unclipped surrogate identifies two channels the correction acts through and three conditions under which it carries signal; an enumerable testbed confirms the conditions' predictions. On hard credit-assignment scheduling tasks, a short corrected warmup with aggressive early sample reuse learns faster than PPO and than the same reuse uncorrected; the marginal gain grows with task difficulty ($+0.02$ to $+0.09$ learning-curve AUC), and the early win over PPO tracks the prefix bias that reuse incurs. A correction held throughout, or applied where clipping already contains the reuse bias, is null to harmful.

Wed 30 SeptMachine LearningArtificial Intelligence
The gist
Many modern reinforcement learning algorithms reuse past experiences to learn better policies, but this reuse can introduce bias that slows down learning or requires cautious updates. The authors studied a way to exactly correct for this bias in certain environments where each state comes from a unique history, like decision trees. They propose a family of corrections that balance bias and variance to improve learning speed without discarding data. Experiments show this correction helps especially on tasks where assigning credit for actions is hard, allowing faster learning compared to popular methods like PPO without the correction.
Open → 2609.39634v1

Statistical bounds for asynchronous td learning with markov data

Sharp Statistical Rates for Asynchronous TD Learning with Markovian Data

Abstract: We study the last iterate of standard tabular temporal-difference (TD) learning from a single trajectory of a finite Markov reward process. For discount factor $γ$, write $H=(1-γ)^{-1}$, and let $μ_{\min}$ and $t_{\operatorname{mix}}$ denote the minimum stationary probability and total-variation mixing time. We prove that last-iterate TD achieves sup-norm error at most $\varepsilon$ with high probability using$\widetilde O\left( \frac{H^3}{μ_{\min}\varepsilon^2} +\frac{t_{\operatorname{mix}}}{μ_{\min}} \right)$ transitions, for $0<\varepsilon\leq1$. This rate holds both for a constant step size selected for the target accuracy and for a decreasing schedule independent of the target accuracy and terminal time. The latter gives a simultaneous guarantee over all times beyond an explicit transient threshold. The statistical term retains the cubic effective-horizon dependence of synchronous TD, and the additive mixing transient has no extra horizon factor. The result allows non-reversible chains, arbitrary initial state distributions, and bounded rewards that may depend on the next state. The proof uses an anchored local Poisson equation in reverse time to control stochastic fluctuations without a mixing-time factor, and a hitting-time compensation identity to bound initialization error. The latter also yields a finer transient in terms of the worst expected reverse hitting time. A bound on the expected cumulative propagation mass extends this argument to decreasing step sizes. A three-state construction with known deterministic rewards gives matching minimax lower bounds for the statistical and mixing terms, up to logarithms, over specified model classes in a slow-mixing parameter regime.

Wed 30 SeptMachine Learning
The gist
Temporal-difference (TD) learning is a way machines predict future rewards based on past experience, but this prediction can be noisy and slow to learn. The paper studies how quickly and accurately TD learning finished running can get close to the best prediction using data generated by a Markov process, which models things that change based on current state. They find precise rates on how long learning takes depending on factors like how much future rewards are valued and how quickly states mix. Their results hold under various conditions and match the best possible bounds, meaning they show TD learning is as efficient as theoretically expected in these settings.
Open → 2609.38880v1

Policy evaluation method improves risk estimation accuracy in rare failures

Tail-Influence Sampling for CVaR Policy Evaluation

Abstract: Policies with similar mean returns can differ sharply in rare failures, yet estimating lower-tail conditional value-at-risk (CVaR) accurately can require many costly rollouts. When different conditional components of a stochastic workflow can be queried separately, we ask how to allocate a fixed evaluation budget to estimate a fixed policy's CVaR most accurately. We derive a tail influence for each queryable conditional law that aggregates how its uncertainty affects CVaR across every Bellman reuse. Its variance yields the fixed-design efficiency bound and the oracle Neyman allocation. Tail-Influence Sampling (TIS) estimates these influence scales from a pilot model and reallocates fresh queries toward kernels that matter most for the tail; a visitation-anchored variant protects against pilot underallocation. Under fixed dimension and a positive quantile margin, TIS attains oracle asymptotic variance and first-order MSE including pilot cost, while the anchored variant is within a factor two of the oracle. We also characterize an exact-grid regime in which tail- and mean-optimal allocations coincide. On CliffWalking, TIS reduces MSE by 41% versus learned occupancy and 76% versus complete rollouts at the same charged transition budget. In frozen language-model review workflows, anchored TIS beats an equally regularized mean-influence blend in 23 of 24 MMLU-Pro settings and reaches 2.4-3.4$\times$ lower MSE than rollouts on six-call FinQA reviews.

Tue 29 SeptMachine Learning
The gist
Sometimes, policies that seem good on average can still fail badly in rare cases. The authors study how to better estimate the risk of these rare failures by focusing on the lower tail of possible outcomes. They propose a method called Tail-Influence Sampling that spends evaluation effort where uncertainty most affects risk estimation, improving accuracy while using the same resources. Their method is tested on simulated environments and shows significant error reductions compared to common approaches.
Open → 2609.38096v1

Markovian nonconvex ADMM achieves stable convergence in reinforcement learning

Markovian Nonconvex ADMM for Reinforcement Learning: Bellman-Resolvent Stability Beyond Smooth Blocks

Abstract: We identify and study a structural mechanism for Markovian nonconvex ADMM in reinforcement learning. Using finite discounted MDPs as a canonical proving ground, we show that the discounted Bellman resolvent $(I-γP_π)^{-1}$ can provide the multiplier stability that classical nonconvex ADMM analyses often obtain from a designated smooth block. Starting from this mechanism, we establish convergence under controlled Markov sampling and then under stochastic observations using an empirical Bellman surrogate that jointly represents the random residual and its Jacobian. Markov mixing, initialization drift, observation noise, and decaying bias enter as one operator perturbation, avoiding unbiased product and double sampling requirements. When the perturbations are square summable, the true KKT residual converges almost surely to zero. Under a finite conditional fourth moment condition, a companion iterate satisfies $ \mathbb{E}[\widetilde G_{K+1}] \le A/T+(B/T)\sum_{k<T}m_k^{-1}, $ which becomes $O(T^{-1}+T/N)$ for total Markov sample budget $N$, giving $O(ε^{-1})$ iteration complexity and $O(ε^{-2})$ sample complexity for squared KKT accuracy $ε$. Beyond stationarity, discounted occupancy coverage yields $J^\star-J(π)=O(\sqrt G)$ for direct tabular policies, so covered exact KKT points are globally optimal, while a statewise quadratic Bellman-improvement condition sharpens the relation to $O(G)$. Finally, nonlinear policy, projected Bellman, and explicit occupancy formulations exhibit the same chain of operator invertibility, dual representation, and multiplier stability. This supports discounted operator invertibility as a reusable structural principle for primal-dual reinforcement learning.

Tue 29 SeptMachine Learning
The gist
This paper studies a mathematical method called ADMM used to train decision-making systems in environments modeled by Markov processes. The authors show that a key tool from reinforcement learning called the discounted Bellman resolvent ensures stability and convergence even when the problem is nonconvex and lacks smooth parts. They prove the method works under realistic sampling conditions and noise, and that the solution quality relates to how well the learned policies cover the environment. This structural insight could help improve primal-dual algorithms for reinforcement learning.
Open → 2609.36859v1

Finite-time convergence rates for two-speed stochastic learning with constraints

Finite-Time Concentration and Convergence Rates for Projected Two-Time-Scale Stochastic Approximation with Markov Noise

Abstract: We study finite-time concentration and convergence rates for projected two-time-scale stochastic approximation driven by a controlled Markov chain. The averaged fast map is contractive, while the slow iterate is projected onto a compact convex polyhedron. The associated projected ordinary differential equation may have a discontinuous vector field at the boundary, preventing a direct application of standard analyses based on Lipschitz vector fields. Using the Skorokhod map, we establish explicit high-probability bounds for tracking the moving fast equilibrium and the projected slow dynamics. These bounds separate martingale fluctuations, Markov-noise residuals, and the bias due to time-scale separation. A Lipschitz Lyapunov function satisfying a uniform decrease condition over fixed time intervals yields almost-sure convergence, with explicit last-iterate rates when the decrease admits a power lower bound. Under uniform Lyapunov contraction, polynomial step sizes yield joint fast-tracking and slow Lyapunov-error exponents arbitrarily close to $1/3$. Under the additional assumption that the reduced slow update map is a Euclidean contraction, logarithmically separated step sizes improve the joint rate to $O(n^{-1/2}\log n)$ almost surely, including for boundary equilibria. The same rate holds under a distinct geometric condition involving a strictly attracting face of a box and a fast equilibrium that is constant on that face. An actor-critic application achieves an almost-sure value-gap rate of $O(n^{-1}\log n)$ relative to the optimum within the constrained policy class. Further applications include projected TD(0) and projected stochastic gradient descent. We also extend the analysis to projection of the fast recursion under Euclidean contractivity.

Mon 28 SeptMachine Learning
The gist
This paper looks at a mathematical method for learning systems that update at two different speeds under some limits and randomness influenced by changing conditions. The authors show how to measure how fast these updates get close to their goals even when the system has boundaries and unpredictable noise. They provide clear ways to separate different sources of error and prove the method will reliably settle down over time, improving certain learning algorithms like actor-critic methods. Their results also apply to other constrained learning tasks that use projection and random feedback.
Open → 2609.34791v1

Flexibility in diffusion language models improves output diversity

Low-Confidence Remasking Traps Flexibility: Realizing Arbitrary-Order Potential for Diverse Rollouts in Diffusion LLMs

Abstract: Masked diffusion language models support arbitrary-order generation, suggesting a natural way to produce diverse outputs. However, recent work argues that this flexibility reduces diversity by delaying high-uncertainty tokens that can lead to different generation paths. We trace this diversity loss not to arbitrary-order generation itself, but largely to low-confidence remasking (LCR), a widely used decoding rule. At each step, LCR samples a token at every masked position but commits only the sampled token with the highest probability, filtering out the rest. We show that this mechanism can exponentially suppress lower-probability tokens as more positions compete, and observe the same suppression in LLaDA. In contrast, top-probability position selection (TPP), which has often been conflated with LCR under the shared label confidence-based decoding, avoids this diversity loss. TPP first selects the position whose most likely token has the highest probability, then samples directly from that position's distribution. Replacing LCR with TPP restores diversity and yields Pass@$k$ comparable to left-to-right decoding, suggesting that the reported diversity loss stems largely from LCR's filtering rather than from generating high-confidence positions first. To further exploit order flexibility, we introduce Entropy-Guided Initialization (EGI), which samples the first token at the highest-entropy position and then follows TPP. This simple modification further improves rollout diversity and solution coverage beyond left-to-right decoding, with gains extending to downstream policy optimization, highlighting the potential of arbitrary-order generation for diverse rollouts.

Mon 28 SeptMachine LearningComputation and Language
The gist
Some advanced language models can fill in missing words in any order, which should create more varied text options. But a popular way to choose which words to fix first, called low-confidence remasking, can actually reduce variety by ignoring less likely words too often. The authors show that using a different method, top-probability position selection, keeps more diversity and matches traditional word-by-word methods. They also introduce a way to pick the first word based on uncertainty, further boosting variety and usefulness in tasks that benefit from diverse outputs.
Open → 2609.34509v1

Observation-safe coupling reduces noise in imperfect-information learning

OSCC: Certified Observation-Safe Coupling Optimization for Gradient-Noise Control in Imperfect-Information Learning

Abstract: Coupled rollouts can reduce the noise of counterfactual action comparisons, but two issues prevent standard common-random-number constructions from serving as a general learning primitive in imperfect-information environments. First, an invalid coupling may expose hidden state, synchronize endogenous policy randomness, or misalign chance events after counterfactual histories diverge. Second, in multi-action policy optimization, lower return-contrast variance is not by itself the relevant objective: the optimizer depends on the return covariance matrix after projection through the local policy-gradient geometry. We introduce observation-safe counterfactual coupling (OSCC), a framework that defines an admissible class through marginal preservation, information-state safety, branch-local policy randomness, semantic event alignment, and trace-before-oracle replay. We derive a gradient-aware coupling criterion showing that, for marginal-preserving couplings, policy-gradient noise changes are determined by policy-Jacobian-weighted off-diagonal return covariance. This motivates OSCC-Select, a calibration-only selector that chooses among independent, root-only, continuation-only, and fully coupled rollouts using separate safety and gain certificates. Its gain target combines projected gradient noise with measured physical sampling cost and falls back to independent sampling whenever a simultaneous lower confidence bound does not certify improvement. On 100,000 fixed-root Leduc comparisons, the fully coupled CP-GRPO instantiation reduces return-contrast variance from 41.1158 to 18.1441, a 55.87% reduction, while preserving the declared branch marginals. With three actions, OSCC-Select chooses continuation coupling and attains gradient-noise trace 0.0783 versus 0.0917 for return-variance selection. Increasing calibration from 64 to 2,048 groups raises certification from 0.327 to 0.995.

Sun 27 SeptArtificial IntelligenceComputer Science and Game TheoryMachine Learning
The gist
Learning to make decisions when you don’t have all the information is tricky because it’s hard to compare what might have happened if you made different choices. The authors identify problems with usual ways to simulate alternatives and introduce observation-safe counterfactual coupling (OSCC), a method that carefully links these alternative scenarios without revealing hidden details or mixing up random events. This approach lowers the noise in estimating how good different choices are, helping the learning process be more stable and reliable.
Open → 2609.33543v1

Posterior sampling achieves optimal exploration rates in reinforcement learning

Minimax-Optimality of Posterior Sampling for Reinforcement Learning

Abstract: Posterior sampling for reinforcement learning (PSRL) is one of the simplest and most effective exploration methods, but a basic question has remained open: does unmodified PSRL achieve minimax regret without structural assumptions on the prior? We answer yes. Exact vanilla PSRL is minimax optimal in leading-order Bayesian regret under arbitrary correlated priors. The difficulty is that a posterior-sampled transition model is coupled with its own continuation value. We overcome this with a common empirical transition reference that isolates the resulting value mismatch and a Bellman-based variance argument that controls it without an extra leading-order state-space factor. For finite-horizon, time-inhomogeneous tabular MDPs with unknown stochastic rewards, this yields the minimax $\widetilde{O}(\sqrt{SAH^3K})$ regret rate under arbitrary joint priors over rewards and transitions. The same proof principle gives the minimax $\widetilde{O}(d\sqrt{H^3K})$ rate for linear-mixture MDPs under arbitrary joint parameter priors.

Sun 27 SeptMachine Learning
The gist
Reinforcement learning helps computers learn to make decisions through trial and error. One popular method, posterior sampling, was simple but it wasn’t clear if it worked as well as possible in the most general situations. The authors show that this method actually does achieve the best possible performance in terms of learning speed and decision quality, even with complex prior knowledge. They used mathematical tools to carefully analyze why it works so well, confirming its effectiveness without extra assumptions.
Open → 2609.33246v1

X-Tree improves multi-step agent learning with reusable experience trees

X-Tree: Tokenizing Reusable Experience for Efficient Agent Generalization

Abstract: Multi-step agents are trained on flat action streams: SFT and RLVR weight every token uniformly and ignore the sub-procedures that recur across tasks, the hierarchy that lets humans plan top-down from reusable routines. This structure sits unused, and flat training uses each scarce trajectory less fully than its content allows. Recent agents do use that structure, but only as LLM-written skills in context, never in the weights, so their gains do not generalize beyond retrieval. We instead recover this hierarchy from the data itself and train on it, with no LLM calls. Following text tokenizers, which build a vocabulary by counting alone, we score action spans by reusability and merge canonicalized actions into a reusable eXperience tree (X-Tree). Each X-Tree node captures how a frequent and success-bearing skill is composed from sub-skills, guiding efficient generalization. We integrate X-Tree into three training settings: offline RL, with each node as a training instance; online RLVR, with an adaptive skill bonus; and on-policy self-distillation, with X-Tree as the self-teacher's privileged context. Across WebArena, ScienceWorld, and WebShop at three model scales, X-Tree improves over standard recipes at matched data and budget by up to 4.5% SR on WebArena, 5.8% SR on ScienceWorld and 4.1% success on WebShop. Matched analyses attribute the gains to the X-Tree structure and the three integrations.

Sat 26 SeptArtificial Intelligence
The gist
Multi-step AI agents usually treat every action they take as separate, missing the fact that some skills repeat and can be grouped into routines. The authors created a way to automatically find these reusable action groups from data, building a tree-like structure called X-Tree that helps agents learn more efficiently. They tested X-Tree in several simulated environments and showed it helps agents succeed more often than standard methods. This approach works without relying on external language models and improves generalization by capturing hierarchical skills.
Open → 2609.32993v1

Soft actor critic training issues tracked by early value size growth

Rank Collapse Is Recoverable, Growing $|Q|$ Is Not: Out-of-Sample Early Warning for Value Divergence in High-UTD Soft Actor-Critic

Abstract: Raising the update-to-data (UTD) ratio breaks off-policy critics in two ways grouped as "plasticity loss": collapsing representations and growing value magnitude $|Q|$. We separate them in Soft Actor-Critic (SAC) with scaled critics (width 2048, no normalization). Collapse is survivable: at UTD ratio 16, HalfCheetah critics with most units dormant keep learning, and the training guard, which stops runs whose loss or $|Q|$ explodes, never flags them. Within one high-UTD SAC configuration, runs start close together, and how far a critic's $\log_{10}|Q|$ has climbed by step 15k, its early growth, ranks the runs by how soon the guard flags them. At 15k, a flagged run's $|Q|$ sits a median of over a hundredfold below its flag level, yet the climb's rate already orders the flags (Harrell's C and out-of-sample AUC 0.78 on Walker2d, 0.98 on Ant, at UTD ratio 4). Dormancy does not. Aborting on this rate saves about a tenth of held-out Walker2d compute and stays net-positive live. A LayerNorm critic lowers the rate, removes the flag on Walker2d at UTD ratio 4 and lowers the return.

Sat 26 SeptArtificial IntelligenceMachine Learning
The gist
Training AI agents to learn from experience can run into problems when the agent updates too often between new data. The authors studied two issues that cause failures in a popular learning algorithm called Soft Actor-Critic: the representation collapses or the value estimates grow too large. They found that value growth early in training, measured by the size of the Q-values, predicts which runs will fail later, but representation collapse does not. Detecting this early can save computation by stopping bad training runs in advance, and adding normalization changes these dynamics and affects final performance.
Open → 2609.32819v1

Policies naturally absorb trainable action offsets they can express

Action Shaping: Policies Absorb What They Can Express

Abstract: Reward shaping has a theorem: a potential-based term can be removed without changing the optimal policy. The same practice on the action channel, an offset added in training and dropped at deployment, has no theorem. Nothing cancels an action offset, so the correction is kept at deployment or removed without a guarantee. We call it action shaping and state its principle. A trainable policy absorbs an offset its own output layer can reproduce exactly, which is what we mean by express; what is absorbed can be removed with the return intact. Its minimal instance is a zero-initialized linear head behind a learnable gate, added to an actor that trains through a learned action-value function, with no penalty or schedule. The gate rises and then falls on its own, for deterministic and stochastic actors alike, and on 20 tasks removing the head costs almost nothing. The condition is exact reproduction, not capacity: a nonlinear head with more parameters is not absorbed, and in a paired control, one linear path added to a nonlinear base head restores absorption. Exact reproduction gives the loss a flat direction that gradient noise drifts along, and the offset's amplitude indicates, before removal, what dropping the head will cost. Action shaping thus gains the counterpart of the shaping theorem, a condition for absorption, together with the mechanism behind it and a diagnostic that reads it. Policies absorb what they can express, and only that.

Sat 26 SeptArtificial IntelligenceMachine Learning
The gist
This paper looks at how machine learning policies handle small changes added to their actions during training. The authors show that if a policy can exactly recreate these changes in its own output, it will absorb them and leave its decisions unchanged when those changes are removed later. They provide a clear condition for when this happens and how to detect it. This helps understand a common practice where adjustments are added during training and then removed during use, something without a formal guarantee until now.
Open → 2609.32752v1

Generalization gaps in reinforcement learning depend on action rules and baseline scores

What Does a ProcGen Generalization Gap Measure? Action Rules, Convergence, and the Missing Random Floor

Abstract: A generalization gap in reinforcement learning (return on training levels minus return on held-out levels) is usually reported without a reference point. We argue that the missing reference is a measured random floor: the return of a uniform-random policy on the same levels under the same harness. On ProcGen, the floor changes what several standard numbers mean. On identical checkpoints and levels across eight environments, switching between sampled and greedy (argmax) test-time actions moves held-out return in both directions, and greedy evaluation takes three environments to or below the floor: in miner, the sampled policy scores 4.9x the floor on held-out levels while its argmax scores below it. Raw policy entropy places seven of eight environments short of convergence, but 35-65% of that entropy is spread across actions with identical effects; after merging them, one to three remain short, and against the floor only heist has learned nothing that transfers. An audit of twelve prior ProcGen codebases finds that all eleven with held-out evaluation sample test-time actions for their policy-gradient agents, nine by default rather than explicit choice, and six report running in-loop averages rather than evaluating a fixed checkpoint. Applied to our own case study, the same checks grade down a statistically significant encoder effect and rule out a within-encoder train-vs-test CKA statistic. We recommend that every reported gap state its action rule, use a matched and seeded protocol, and report the random floor on both level sets.

Sat 26 SeptMachine LearningArtificial Intelligence
The gist
When evaluating how well AI agents trained on some video game levels perform on new unseen levels, there is usually a difference called a generalization gap. This paper points out that to understand this gap properly, you need to compare agent scores not only to training scores but also to how a completely random player would perform on those levels. The authors show that how you pick the agent’s actions during testing (random sampling versus always choosing the best action) changes the measured performance a lot. They also find that measuring randomness in the agent’s choices is unclear because some different actions have the same effect. These insights suggest ways to better measure and report AI generalization in such games.
Open → 2609.32532v1

Stochastic contraction framework improves td learning convergence analysis

A Contraction Framework for Stochastic Operators with Bootstrapping: Application to TD Learning

Abstract: Many iterative algorithms rely on bootstrapping. A variable is updated using a second, frozen copy as a target, which is periodically replaced with the updated variable. Majorize-minimize and inexact proximal-point methods share this structure, as does temporal-difference (TD) learning. However, existing convergence guarantees for scenarios that combine sampled updates with targets refreshed only every $K$ steps rely on the specific structure of the update, such as linear approximation or gradient-based inner steps, and on uniformly bounded sampling error. We instead model the sampled update as a stochastic operator on the parameter space, which reduces the analysis to a contraction argument that needs no gradient structure and allows the sampling error to grow with the iterates. Within this framework, we derive a finite-time bound for i.i.d. samples and any target-update period $K$. We show that the iterates converge geometrically in root mean square to a ball around the fixed point, provided the sensitivity to the frozen target is smaller than the contraction slack of the inner map. Existing deterministic frozen-target contraction and stochastic-gradient-type bounds follow as special cases of our framework, and simulations of TD learning reproduce the predicted contraction rate and scaling of the error floor with the step size.

Thu 24 SeptMachine Learning
The gist
Many methods that learn by updating estimates based on parts of themselves use a technique called bootstrapping, but analyzing how well this works when updates happen intermittently and with some randomness is hard. The authors model these updates as a kind of shrinking process called a stochastic contraction, which simplifies the analysis and allows for greater flexibility in errors growing with the learning steps. They prove the learning process converges steadily to near the correct answer under clear conditions. This general approach helps unify previous specific results and matches test simulations on temporal-difference learning.
Open → 2609.29961v1

Actor critic algorithm maintains reliable learning with high probability

A Concentration Bound for Two-Timescale Actor-Critic Algorithm

Abstract: Significant research effort has been directed in recent years towards establishing both asymptotic and non-asymptotic convergence guarantees for two-timescale actor--critic algorithms, where the actor recursion is run on a slower timescale than the critic recursion. This work derives a uniform all-time concentration bound for the actor--critic algorithm with function approximation in the long-run average-reward setting. This bound helps us analyze the behavior of the actor parameter with high probability. We show that, after some finite time, the actor parameter enters a safe region and remains within it thereafter with high probability. Specifically, with probability at least $1-ε_1-ε_2$, the actor error $\Vert θ_k-θ^{*}\Vert$ is $O\left(\frac{n_0^{3/4}}{k}\frac{1}{\sqrt{ε_2}}+\left(\frac{1}{n_0}\right)^{1/4}\log^{1/4}\left(\frac{1}{ε_1}\right)+\left(\frac{1}{n_0}\right)^{1/4}\right)$ for all $k\geq n_0$ and sufficiently large $n_0$. We also present experimental results demonstrating that the aforementioned actor error diminishes with the number of actor-parameter updates.

Thu 24 SeptMachine Learning
The gist
This paper addresses how a type of machine learning algorithm called actor-critic, which learns by updating two parts at different speeds, behaves over time. The authors developed a mathematical guarantee that with high probability, the algorithm’s 'actor' part stays close to the best solution after enough updates. They also confirmed with experiments that the error indeed gets smaller as learning progresses. This helps increase trust in using actor-critic methods for long-term decision tasks.
Open → 2609.29117v1

Compact intervention structures persist in high-dimensional recurrent model dynamics

Compact but Moving: Intervention-Relevant Geometry in Recurrent World Models

Abstract: Learned world models may have compact interventions even when their recurrent state is high-dimensional, but it is unclear what happens to such a correction after it enters the model. We study this question in a controlled recurrent world model where prior work identified a checkpoint-specific rank-4 interface for one-shot counterfactual velocity interventions. The correction rapidly leaves this fixed entry subspace during autonomous rollout. Nevertheless, a low-rank image obtained by transporting the entry directions through the factual recurrent Jacobian chain continues to capture most of the nonlinear correction. Restarts using the tangent-predicted correction preserve substantial counterfactual future function. This transport/function pattern recurs across independently trained structured-GRU models and a parameter-matched LSTM initialized with a privileged compact correction. We further characterize a finite-horizon future-response operator over the full recurrent carrier. Patching shifts its leading future-sensitive directions toward the matched native-counterfactual organization, and the local operator accurately ranks finite perturbation effects over the registered direction panels at the patched and native-counterfactual basepoints. A separate full-amplitude assay finds substantial factual-endpoint tangent residuals and supports response reconfiguration in two of three checkpoints. Together, these results show that compact intervention structure can persist as a moving, state-dependent local geometry embedded in high-dimensional recurrent dynamics, without implying a fixed or dynamically closed low-dimensional state.

Fri 18 SeptRobotics
The gist
This paper explores how small but meaningful changes (interventions) in complex time-based computer models behave internally. The authors found that although models have many moving parts, the key corrections to their behavior can be represented in a compact, changing geometric pattern rather than a fixed low-dimensional space. This pattern helps predict how the model will respond to changes over time and is consistent across different types of recurrent neural networks. Their work shows that concise intervention information can move and adapt internally without losing its usefulness.
Open → 2609.21787v1

Care-vi improves reliability in off-policy actor-critic learning

CARE-VI: Conservative Adaptive Reliability Estimation for Value Improvement in Off-Policy Actor-Critic Learning

Abstract: Reliable temporal-difference targets are central to off-policy actor-critic learning. Direct value improvement refines the next-state target with alternative actions, but the reliability of this refinement depends on how candidate actions are ranked, reviewed, and weighted. Noisy rankings may force premature candidate commitment, reusing selection scores may bias target valuation, and fixed enhancement weights may amplify weak evidence. To address these risks, we develop Conservative Adaptive Ranking and Screening (CARS), which retains an ordered candidate prefix within a preset budget and narrows it only when the observed boundary gap exceeds a disagreement-scaled uncertainty radius. Selector-Evaluator Value Assessment (SEVA) uses selector critics to order candidates and a separately parameterized evaluator critic to review the selected value, then caps the reviewed value at the selector reference. Dynamic Adaptive Risk-aware Enhancement (DARE) then regulates each residual correction using candidate reliability, the gap between selector and evaluator signals, and a finite stage factor. Together, CARS, SEVA, and DARE form CARE-VI, an evidence-regulated target construction framework that preserves the backbone interfaces for critic regression and actor updates. The analysis bounds the CARS boundary error, the SEVA selected-value overestimation, and the one-sided deviation of the DARE residual displacement from its population counterpart, and establishes fixed-policy recovery after the finite-stage perturbation ends. Experiments with SAC, TD3, and TD7 on four MuJoCo tasks show that CARE-VI achieves the highest mean return in all twelve settings. Grouped ablations and scalar diagnostics support the roles of the three components in improving target reliability.

Thu 17 SeptMachine Learning
The gist
Improving decision-making in AI agents relies on accurately estimating values of future actions, but noisy data can lead to premature or biased choices. The authors created CARE-VI, a framework that carefully ranks and reviews possible actions, adjusts corrections based on reliability, and avoids overconfidence in value estimates. This approach helps AI agents learn better policies by making more trustworthy predictions of future rewards. Experiments on standard robotic tasks demonstrated that CARE-VI outperforms existing methods by producing higher average returns.
Open → 2609.20098v1

Reference policies guide equilibrium choice in strategic self-play

Steering Equilibrium Selection in Regularized Self-Play via the Reference Policy

Abstract: Regularized self-play -- the family behind DeepNash's Stratego play -- drives a two-player zero-sum policy to a Nash equilibrium by best-responding to a slowly moving, entropy-regularized reference policy $ρ$. When the game has a polytope of value-equivalent equilibria, the regularizer silently breaks the tie: with a uniform reference it selects the maximum-entropy member, the I-projection of $ρ$ onto the Nash set. Can the reference be used to choose the equilibrium on purpose? On five exactly solvable games plus a 2-D polytope, with exact best responses and equivalence tests over independent seeds, anchoring the reference at a target member and refining steers self-play to that member with mean coordinate error 0.007 at median exploitability $5\times10^{-5}$, TOST-equivalent to the request within $\pm0.05$; the anchoring persists through refinement and follows the reference, not the initialization. Selection follows the reach-weighted I-projection (slope 0.969 [0.950, 0.987]). We report with equal emphasis where the story breaks: fixed off-manifold references cost 0.08-0.25 exploitability; stiff or flat families require a smaller mirror step, set by a pre-registered rule; boundary targets undershoot; curvature predicts where boundary saturation bites (rank correlation 0.90, p=0.037) while interior precision is curvature-independent. Table and MLP steering maps are equivalent within $\pm0.03$ at every target (30 seeds); matched control arms show attention's robust signature is excess seed variance, any systematic shift bounded at 0.018 and not significant. Against a best response the selection-robustness trade-off is degenerate: steering matters only against fixed, non-equilibrium opponents. The recipe -- anchor the reference at the desired member and refine -- reinterprets the KL anchor of RLHF-style RL as a selection knob, not only a stability leash.

Thu 17 SeptArtificial IntelligenceComputer Science and Game TheoryMachine Learning
The gist
In some strategic games, there can be many equally good ways to play, making it unclear which strategy a learning algorithm will choose. The authors study a method that nudges the learning process toward a specific desired strategy by tweaking a guiding reference policy. Their experiments confirm this approach works precisely when tested on small games where exact calculations are possible. They also identify limitations and conditions where steering the choice is harder or less reliable. This helps clarify how a guiding policy influences outcomes in algorithms that learn by playing against themselves.
Open → 2609.19820v1

History dependent logging makes policy evaluation exponentially hard

Exponential Hardness of Off-Policy Evaluation under History-Dependent Logging

Abstract: Can a logged dataset visit every hidden state frequently and still be exponentially uninformative about a target policy's value? We show that it can when the logger depends on history. For every horizon $H \ge 3$, we construct two POMDPs with at most two latent states per stage, three actions, and a common logger with three memory states. Action coverage, belief coverage, and two behavior-marginal outcome-revealing conditions all have constants independent of $H$. Nevertheless, evaluating a known deterministic target policy to accuracy $1/8$ requires $Θ((3/2)^H \log(1/δ))$ logged episodes at confidence $1-δ$, for $0 < δ\le 1/4$, even when both candidate models are known. The mechanism is simple: a reset erases the unknown transition that determines the target value. We characterize the resulting statistical experiment exactly and obtain a matching optimal estimator. A directed two-lane gridworld realizes the construction, and trajectory simulations agree with its finite-sample prediction. The result establishes intractability for the history-dependent-logging, model-based case posed by Zhang and Jiang (2025, arXiv:2503.01134), under their behavior-marginal definition of revealing.

Wed 16 SeptMachine Learning
The gist
Estimating how well a certain plan (policy) will work using past data can be very difficult if the data collection depends on previous events. The authors show that even when the system seems to have good coverage and the models are known, the number of samples needed to evaluate a policy grows exponentially with the length of the decision process. They build simple examples where a single reset action erases key information, making the problem much harder. Their findings prove that past assumptions about ease of evaluation under these conditions do not hold.
Open → 2609.19135v1

Convergence bounds clarify error sources in deep reinforcement learning

A Convergence Framework for Deep $V$-Learning: Error Propagation and Sharp Action-Gap Bounds

Abstract: We establish convergence bounds for deep $V$-learning with horizon $H$. The algorithm fits a scalar value function to targets from executed transitions and selects actions using a predictive model and the value function. For current observed-successor targets with fresh true-kernel outcomes, the conditional mean is $\mathcal{T}^βV$, which averages over behavior-policy actions. The Bellman optimality update is $\mathcal{T} V$. We decompose the update error into six residuals: fitting, transition reuse, target construction, replay, action selection, and exploration. Under $L^s$ concentrability, their $L^p$ norms ($p=s/(s-1)$) control expected $L^1$ policy loss. The bound explicitly weights residuals from only the last $H-1$ update blocks, plus an initialization term for shorter runs. We quantify the cost of a shared sampling distribution across horizon levels. For statistical error bounds of order $n^{-ν}$, we derive optimal continuous allocations and an integer allocation whose objective is within a factor $2^ν$ of the constrained optimum. A margin condition with exponent $α$ gives action error of order $Λ^{1+α/p}$, where $Λ$ combines network drift and score error; a one-step construction proves the exponent sharp. Bounds on the distance between frozen and optimal scores transfer an optimal-gap condition to frozen-iterate gap bounds while retaining the mass of optimal ties. Survival probabilities and coverage conditions at deployment yield bounds for policies selected with approximate scores. Separate spatial ReLU networks per horizon level give a conditional neural regression rate, and the finite-state case gives a log-free expected fit rate. These results give expected policy-loss consistency for the fixed-horizon generative-reset approximate-ERM procedure with exact action scores and provide an explicit residual-decay criterion for FIFO/interleaved SGD.

Wed 16 SeptMachine LearningRobotics
The gist
This paper studies how deep reinforcement learning algorithms that estimate future rewards can be mathematically guaranteed to get closer to the best possible decisions over time. The authors break down different sources of errors in the learning process and show how these errors combine and affect the overall performance. They provide formulas that explain how quickly and accurately the algorithm learns depending on factors like data reuse, action choices, and exploration. Their work helps understand when and why these algorithms work well and gives guidelines for ensuring consistent improvement. This kind of analysis supports building more reliable AI systems that learn from experience.
Open → 2609.18782v1

Quantum neural networks improve time series and learning tasks

Learning to Program Adaptive Non-Local Observables for Machine Learning

Abstract: Quantum neural networks (QNNs) are typically built from variational quantum circuits (VQCs), which are limited by local measurements. Adaptive non-local observables (ANO) address this by jointly optimizing circuit parameters and multi-qubit measurements. However, existing ANO-based VQCs learn only a single static observable that remains invariant across all inputs. We propose QFWP-ANO, a novel architecture which employs a classical hypernetwork to dynamically program VQC parameters and/or non-local observables conditioned on each input. On multivariate time-series forecasting across four ETT datasets, QFWP-ANO achieves the lowest MSE in 16 of 20 settings and second-lowest in the remaining four, surpassing ANO-based and other strong baselines. On reinforcement learning tasks, QFWP-ANO consistently surpasses ANO-VQCs. Our results establish input-conditioned ANO as an effective approach for enhancing QNNs.

Wed 16 SeptMachine Learning
The gist
Quantum neural networks usually use fixed ways to measure their outputs, which can limit how well they work. The authors created a method that lets the network change how it measures information based on each input, making it more flexible. They tested this on predicting complex time-based data and in reinforcement learning tasks, finding that their approach performed better than previous methods. This shows that adapting measurements in quantum networks can help them learn and predict more accurately.
Open → 2609.18655v1

Symmetric strategies solve repeated harmony game using Bellman equation

Symmetric solution of the Bellman optimality equation for repeated harmony game

Abstract: In social dilemma games, additional rewards or punishments have been studied as means of promoting cooperation. Therefore, it is important to investigate the ideal situation, in which such an additional payoff would change the game. In this study, we investigated the symmetric solution of the Bellman optimality equation for a repeated harmony game. The calculations showed that three types of symmetric solutions exist. One of them corresponds to the trivial All-C strategy, and another to the Win-stay Lose-shift strategy of the prisoners dilemma game. The nontrivial behavior of the strategy corresponding to the last solution is also discussed in detail. In addition, we numerically investigated which strategy the agents actually learn by the reinforcement learning algorithm.

Mon 14 SeptComputer Science and Game TheoryArtificial IntelligenceMachine Learning
The gist
Social dilemma games study how people cooperate or compete when rewards or punishments are added. This paper looks at a specific type of repeated game called a harmony game and finds three main types of cooperative strategies that can emerge. One strategy matches always cooperating, another matches a known win-stay lose-shift behavior, and the third is more complex. The authors also explore which of these strategies can be learned by artificial agents using reinforcement learning.
Open → 2609.16289v1

Connecting control theory and machine learning for smarter systems

Bridging Control, Inference, Transport, and Thermodynamics: From Theory to Applications in Learning

Abstract: The last decade has seen the development of powerful methods for learning complex structure from high-dimensional data. These advances have brought to the foreground fundamental connections between subdisciplines of physics, applied mathematics, and machine learning. In this review, we bring together some of these ideas, often expressed in different languages, to highlight a conceptual thread that links five distinct fields: control theory, optimal transport, probabilistic inference, non-equilibrium thermodynamics, and machine learning. A common theme is the optimization of free-energy-like functionals under dynamical or statistical constraints. We offer a guided tour through this thread and present selected applications in reinforcement learning, variational inference, and generative modeling. The review does not assume prior familiarity with these topics, and begins with principles originating from physics.

Mon 14 SeptMachine Learning
The gist
Complex data is hard to understand and use, so the authors highlight how ideas from physics, math, and machine learning come together to help. They show that five areas—control, transport, inference, thermodynamics, and machine learning—share a common goal: optimizing certain mathematical functions under constraints. This connection allows for new ways to improve learning methods like reinforcement learning and generating models. The paper explains these links in simple terms starting from basic physics ideas.
Open → 2609.15897v1

Stochastic approximation steady-state limits with markov noise and non-smooth functions

Steady-State Convergence of Stochastic Approximation

Abstract: For constant-stepsize stochastic approximation (SA), the iterates converge in distribution to a stationary law that depends on the stepsize $α.$ Steady-state convergence (SSC) concerns the limit of the scaled stationary distribution as $α\downarrow 0.$ Existing SSC theory requires i.i.d. or additive noise and global differentiability of the mean operator, and yields suboptimal rates. We develop a unified SSC theory for constant-stepsize contractive SA driven by Markovian, multiplicative noise, covering both locally differentiable and locally nondifferentiable mean operators. A key methodological contribution is a multi-step universality framework that progressively reduces the original stochastic recursion to tractable auxiliary dynamics while preserving its steady-state limit. Under local quadratic linearization at the fixed point, we obtain a Gaussian approximation of the scaled steady state at the optimal rate $O(\sqrtα)$ in Wasserstein-2 distance, which further gives finite-time Gaussian approximations for the raw iterates. In the locally nondifferentiable regime, we establish a general SSC result and show that the leading-order asymptotic bias can be of order $\sqrtα$, in contrast to the $α$-order bias in the smooth regime. We apply the theory to Markovian linear SA and asynchronous Q-learning, neither of which is covered by prior results. We further propose a bias-reduction scheme for Q-learning that requires no knowledge of the local smoothness regime, validated by numerical experiments.

Mon 14 SeptMachine Learning
The gist
Stochastic approximation is a method used to find solutions iteratively under randomness, but understanding their long-term behavior can be tricky. The authors study how these methods behave when the randomness is more complex and when the function being approximated is not perfectly smooth. They provide a unified way to describe the steady behavior and show that the nature of the function affects the accuracy of approximations. Their work covers new cases like certain learning algorithms and includes a way to reduce errors in those cases.
Open → 2609.14922v1

Approximate value iteration achieves strong game play with less cost

The Surprising Effectiveness of Approximate Value Iteration in Self-Play

Abstract: Combining search with function approximation has driven major advances in game-playing programs, making self-play algorithms more competitive than ever. Still, the computational overhead of the most popular methods, based on Monte Carlo Tree Search (MCTS), can be substantial. In this work, we investigate whether simpler methods remain competitive in non-trivial, moderately sized games such as Connect Four, Hex(7x7) and synthetic games. We train a minimal self-play implementation of Approximate Value Iteration (AVI) and use ground-truth oracles for exact evaluation. Contrary to expectations, our results demonstrate the surprising effectiveness of AVI: it learns more accurate value functions than those learned by AlphaZero, while its one-step-lookahead greedy policies remain competitive with MCTS-based policies at substantially lower training and inference costs. Preliminary experiments on Othello and Go(9x9) show that AVI trains stably on larger games and learns effective value functions. These findings suggest that the success of MCTS-based methods may have eclipsed simpler approaches that have become increasingly practical with modern deep-learning tools.

Tue 8 SeptArtificial Intelligence
The gist
Playing games with computers often involves complex methods that are slow and require a lot of computing power. The authors show that a simpler approach called approximate value iteration can learn to play certain board games well, almost as well as fancy search methods, but faster and cheaper. They tested it on games like Connect Four and smaller versions of Go, finding it surprisingly effective. This suggests simpler methods might be a practical choice for game-playing AI than what is commonly used now.
Open → 2609.09094v1

PlayTrain enables fast training on JavaScript-generated video games

PlayTrain: An Efficient Reinforcement Learning Framework for LLM-Generated Adaptable JavaScript Games

Abstract: While many video-game environments (VGEs) have played crucial roles in advancing reinforcement learning (RL), developing novel VGEs or modifying existing ones to support new features, has been a laborious process requiring extensive hand-coding. Here we present PlayTrain, an RL framework that combines the abilities of large language models (LLMs) to robustly generate JavaScript (JS) games from a minimal human prompt, and an efficient pipeline that can run any JS game in a standard 'gym' environment. Not only are recent LLMs particularly good at writing JS code, but the JS format also allows users to easily play generated VGEs, while PlayTrain enables us to train RL agents on the exact same games. We demonstrate multiple use cases of PlayTrain, including cloning well-known Atari and ProcGen games in simple JS, where PlayTrain trains pixel-based agents end-to-end at over 1M agent-decisions per second on a single GPU node; and creating modified versions thereof (e.g., that support novel test sets, procedural generation logics, or game dynamics). Through PlayTrain, we reimagine RL VGE development: all we need is a single JS file, generated and modified through an LLM. We discuss promising future RL research directions that PlayTrain unlocks.

Tue 8 SeptMachine Learning
The gist
Training AI agents to learn video games usually requires a lot of hand-coded work to build or change game environments. The authors created PlayTrain, which uses large language models to automatically write simple JavaScript games from short instructions and runs them in a standard setup for training AI. This approach speeds up the process and allows AI to be trained on new or modified games efficiently. It also supports creating variations of games to test different learning challenges.
Open → 2609.09059v1

Policy update method converges fast in multi-player zero sum games

Last-Iterate Convergence of Policy Dynamics in Zero-Sum Networked Separable Markov Games

Abstract: Solving Nash equilibria for general multi-player Markov games is computationally intractable, while two-player zero-sum Markov games admit fast last-iterate policy-optimization methods. Finite-horizon zero-sum networked separable Markov games occupy an important middle ground: they retain global competition structure through pairwise interactions, while preserving computational tractability of Nash equilibria (NE) in the full-information and known-transition setting. Existing algorithms for this class either proceed through equilibrium-collapse arguments for a simplified setting where a single controller determines the transition probability, or backward dynamic programming that relies on equilibrium solvers at each stage. However, the design and analysis of direct policy-update approaches remain inadequate. To address this issue, we propose the entropy-regularized optimistic multiplicative weights update (ER-OMWU), a complementary single-loop policy dynamic that updates players' policies symmetrically and returns an approximate NE in the last iteration. We provide a first last-iterate convergence analysis of policy dynamics in the games of interest: after $\widetilde{O}(1/ε)$ iterations, the returned policy is an $ε$-approximate Nash equilibrium. The result preserves the near-linear convergence rate achieved by policy optimization in two-player zero-sum Markov games, but extends the policy-dynamics viewpoint to a more complicated but structured multi-player setting.

Tue 8 SeptComputer Science and Game Theory
The gist
Finding stable strategies (Nash equilibria) in games where multiple players interact over time is usually very hard. The authors study a special kind of game where players compete in pairs and all interactions together form a network. They introduce a new way for players to update their strategies that is simple and efficient. Their method quickly finds an approximate solution that no player can benefit from changing, and they prove it converges reliably after a certain number of steps.
Open → 2609.08823v1