✗ Failed on benchmark 2026

Recursive Bellman Variance Targets

Implementation & benchmark of arXiv:2607.14555 — Consistent Variance Estimation for Q-Function Estimators in Finite-Horizon MDP Tree Search

Usefulness7/10
Difficulty5/10
Novelty7/10

Source paper: Consistent Variance Estimation for Q-Function Estimators in Finite-Horizon MDP Tree Search arXiv:2607.14555 ⓘ · analyzed Aug 30, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace the naive sample variance of correlated rollout returns with a recursive variance target attached to every state-action node or latent rollout node. The target separates uncertainty caused by immediate reward noise, stochastic next-state selection, and uncertainty already present in child value estimates, enabling calibrated heteroscedastic Bellman updates and uncertainty-aware rollout allocation.

Formulas

$$m_n=\sum_j p_j(r_j+m_j),\qquad s_n^2=\sum_j p_j\left[s_j^2+u_j^2+2c_j+(r_j+m_j-m_n)^2\right].$$
$$\operatorname{Var}(Y_n)=\mathbb{E}[\operatorname{Var}(Y_n\mid X')]+\operatorname{Var}(\mathbb{E}[Y_n\mid X')].$$
$$\mathcal{L}_{\mathrm{het}}(\theta)=\frac{1}{2}\left[\frac{(G_\tau-v_\theta(s,a))^2}{\widehat{s}_{\theta,\mathrm{rec}}^2+\epsilon}+\log\left(\widehat{s}_{\theta,\mathrm{rec}}^2+\epsilon\right)\right].$$
$$\widehat{s}_{n,\mathrm{rec}}^2=\sum_j\widehat{p}_j\left[\widehat{s}_j^2+\widehat{u}_j^2+2\widehat{c}_j+\left(\widehat{r}_j+\widehat{m}_j-\widehat{m}_n\right)^2\right].$$

Mathematical statement

Let node n=(t,x,a) have random target Y_n=R_n+Z_{X'}, where X' is the next state, R_n is the immediate reward, and Z_{X'} is the child return estimate. Let p_j=P(X'=x_j|x,a), m_j=E[Z_{x_j}], s_j^2=Var(Z_{x_j}), r_j=E[R_n|X'=x_j], u_j^2=Var(R_n|X'=x_j), and c_j=Cov(R_n,Z_{x_j}|X'=x_j). The recursive mean is m_n=sum_j p_j(r_j+m_j), and the total-variance recursion is s_n^2=sum_j p_j(s_j^2+u_j^2+2c_j+(r_j+m_j-m_n)^2). The final squared term is transition-selection variance, while s_j^2 is propagated future-value uncertainty. In a neural network, the child means and variances are predicted by a value head and a variance head, and the variance is detached when used to weight the mean loss.

Implementation notes

Integration point: add a second output head to a value network, producing a mean v_theta(s,a) and nonnegative conditional variance q_theta(s,a)=softplus(h_theta(s,a))+epsilon. For each training transition or imagined branch, retain the child predictions instead of forming only a scalar return. Pseudocode: (1) obtain child means m_j and variances s_j^2; (2) compute z_j=r_j+m_j and m_rec=sum(p_j*z_j); (3) compute q_rec=sum(p_j*(s_j^2+u_j^2+2*c_j+(z_j-m_rec)^2)); (4) detach q_rec; (5) minimize 0.5*((G-m_theta)^2/(q_rec+eps)+log(q_rec+eps)), optionally with a separate stop-gradient regression target for q_theta. When only sampled branches are available, use node-local running counts, reward means, reward second moments, child means, and child variances; do not calculate variance over all complete paths as if they were independent. The paper mechanism supplies the recursive decomposition and estimator structure; transition probabilities, reward variances, and child statistics are estimated from replay or rollout batches. First cheap experiment: train a distributional/value network on CartPole or a small stochastic GridWorld, comparing ordinary MSE plus naive path variance against recursive heteroscedastic Bellman training. Use 1, 2, 4, 8, and 16 imagined branches. The quantitative prediction is that naive root-return variance underestimates held-out return squared error increasingly with branch depth, while recursive variance has calibration ratio E[(G-v)^2]/E[q_rec] near 1.0 and remains within 20% across depths. A second predicted signature is monotonic variance growth with horizon under nonzero transition noise; removing transition randomness should eliminate the between-child term and sharply reduce the gap between recursive and naive estimates.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Inconclusive

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 9/10

Built a finite-horizon stochastic-tree verifier implementing recursive Bellman mean/variance propagation plus a small heteroscedastic regression comparison. The mechanism manifested: recursive variance matched Monte Carlo variance within 0.56% across horizons, the transition-selection term exactly followed p(1-p)Δ² and vanished at deterministic transitions, and horizon variance matched predicted discounted accumulation under both deterministic and random transitions. The neural mini-experiment did not show a performance win: MSE was 0.24654 baseline versus 0.24735 for the idea, with essentially identical calibration ratios.

Agent confidence
9/10
Baseline
Tiny regression: test MSE 0.24654; calibration ratio E[(y-v)^2/q] = 0.27029.
Idea
Tiny recursive-variance-weighted regression: test MSE 0.24735; calibration ratio = 0.27076. Mechanism checks: recursion-vs-Monte-Carlo relative error 0.00002-0.00558; selection term exact over p=0..1; horizon MC/prediction agreement within about 0.5%.

Limitations: This is a controlled toy stochastic process, not CartPole or a trained RL/world-model agent. It uses known transition and reward statistics, does not test learned child variance error, nonzero reward/return covariance, rollout allocation, branch counts 1/2/4/8/16, or compute/FLOP efficiency; the baseline comparison is only a small supervised regression rather than an end-to-end Bellman learner.

How to run: python3 verify.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.14555)

Ahead of the baseline (−4.4%) but not statistically significant (p=0.9399, wins 2 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0042
Idea mean
0.004
Effect (Δ)
-0.0002 (−4.4%; negative = idea better)
Wins
2 / 8 paired seeds
p-value
0.9399 (permutation test, 20 000 shuffles)
Smallest detectable effect
±72.8%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

The initial larger run timed out after 2400 seconds, so the completed protocol used 400 training samples, 200 test samples, 8 epochs, and four stochastic branches. The recursive branch construction is an approximation using perturbations of the final input state rather than a learned environment transition model; reward/child covariance was not separately estimated. The signature aggregation contains a reporting simplification for mean q/observed error, although per-seed calibration ratios were measured from each trained model. No rollout allocation or compute-efficiency comparison was tested.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark latest Failed ✗

Agent confidence: 9/10

Built the recursive Bellman variance intervention on the structurally matched dynamics track using the shared rnn_small backbone, with a variance head, detached recursive child variance, and between-branch variance term. Across 8 paired seeds, MSE changed from 0.004214 baseline to 0.004030 for the idea, but the paired permutation p-value was 0.9399 and only 2/8 pairs favored the idea, so there is no significant win. The trained-model mechanism signature was not confirmed: mean calibration ratio was 0.00516 rather than near 1, with weak negative q/error correlation.

Baseline
Dynamics/rnn_small MSE: mean 0.00421419, std 0.00266828; tuned lr=0.01, epochs=8.
Idea
Dynamics/rnn_small recursive variance training MSE: mean 0.00402988, std 0.00150342; selected lr=0.01, epochs=8; paired delta -0.00018431, p=0.9399, 2/8 wins.
Mechanism signature
Mean recursive q=0.81054 versus observed squared error 0.00542; calibration ratio mean=0.00516; q/error correlation mean=-0.0987; confirmed=false.

Benchmark result

Ahead of the baseline (−4.4%) but not statistically significant (p=0.9399, wins 2 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0042
Idea mean
0.004
Effect (Δ)
-0.0002 (−4.4%; negative = idea better)
Wins
2 / 8 paired seeds
p-value
0.9399 (permutation test, 20 000 shuffles)
Smallest detectable effect
±72.8%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

The initial larger run timed out after 2400 seconds, so the completed protocol used 400 training samples, 200 test samples, 8 epochs, and four stochastic branches. The recursive branch construction is an approximation using perturbations of the final input state rather than a learned environment transition model; reward/child covariance was not separately estimated. The signature aggregation contains a reporting simplification for mean q/observed error, although per-seed calibration ratios were measured from each trained model. No rollout allocation or compute-efficiency comparison was tested.

How to run: python3 stage2_bench.py

Artifacts

Implementation overview ⬇ Download all as ZIP 6 files · code, reports and structured results