The accuracy ceiling (skyline) and acceptance rate (Z) of the no-runtime-error potential
(DS1000RuntimeNoErrorPotential) under exact posterior sampling, across 10 models and 6 temperatures
(59 cells, ~3.8M rollouts). Measured with the literal potential (forkserver, 30 s timeout) scored in
the DS-1000 repo environment (sklearn 1.4.0, numpy 1.26.4, …), matching how the dataset's
passed labels were produced. Matplotlib excluded (image-graded).
Across ~3.8M rollouts the potential produced only 20 false-rejects
(a correct solution it marked as erroring), "runs without error" is an almost lossless filter on correct code.
Those 20 fall on just 10 problems
(7 on one), almost all np.random-based or compute-heavy Sklearn/Numpy tasks: cases where the code's own
runtime outcome varies between executions (random draw, 30 s timeout, memory), not a class of correct code the
potential systematically rejects.
* Qwen2.5-Coder 7B, DeepSeek-Coder: externally ingested (# SOLUTION START/END convention).
Constraint (validity potential). A sample y is valid iff its code runs to completion under DS1000RuntimeNoErrorPotential — no runtime/syntax error and no timeout:
φ(y) = 1[ y passes DS1000RuntimeNoErrorPotential ] ∈ {0, 1}
An answer that runs but returns the wrong value is still valid — the constraint is “does it run”, not “is it correct”.
Constrained-generation target. Let p0(· | x) be the model’s sampling distribution for question x at the given temperature. Enforcing the constraint defines the target distribution
π(· | x) ∝ p0(· | x) · φ(·)
Rejection sampling realises π exactly: draw from p0, discard invalid samples, keep the valid ones. This is what we rejection-sample for — the validity-constrained distribution, not correctness.
Normalizing constant = validity rate. Estimated by simple Monte Carlo over the rollouts:
Z(x) = 𝔼p0(y|x)[ φ(y) ] = Pr( y valid | x ) ≈ (1/N) ∑i φ(yi)
where N is the total number of rollouts sampled for question x. Averaging over all tasks x gives the full Z:
Z = meanx Z(x)
Correctness rate (single-sample accuracy). What we ultimately care about — how often the constrained generator is right — factorises as
Pr( y correct | x ) = Pr( y valid | x ) · Pr( y correct | y valid, x ) = Z(x) · skyline(x)
Averaged over problems, this single-sample accuracy is the pass@1 plotted on the DS-1000 page:
pass@1 = meanx Pr( y correct | x )
Skyline over the benchmark. The second factor, skyline(x) = Pr( y correct | y valid, x ), is the accuracy within the valid set. To report one skyline for the whole benchmark we use the estimator
skyline = pass@1 / Z
equivalently, the fraction of all valid rollouts that are correct:
summing over the N rollouts y of each problem x — Validx the rollouts that pass φ, Correctx the correct ones. Averaging the per-problem ratios instead — meanx skyline(x) — would not give Pr( y correct | y valid): it weights every problem equally no matter how many valid samples it had, so the product no longer recovers pass@1. The pooled estimate weights every valid rollout equally.
Why “skyline”? It is the accuracy of ideal constrained generation: if you could sample exactly from π (enforce validity and nothing else) and ask how often the result is correct, this is the number you would get. The point is that it is a reference for evaluating approximate methods. In practice you rarely have exact access to π — sampling it (e.g. by rejection) is expensive — so an inference method approximates it with some π̃ (importance sampling, SMC, fine-tuning, …). To judge that method you look at the accuracy of samples from π̃ and compare it to this skyline: it tells you how close the approximation gets to the ideal constrained target. Strictly it is not an upper bound: a biased π̃ could exceed it if its bias systematically favours correct solutions (approximation error correlated with correctness) — very unlikely in practice, so we treat it as a skyline / reference rather than a hard ceiling.
For each model and temperature we report the pooled validity rate Z and skyline (DS-1000, Matplotlib excluded), so that pass@1 = Z × skyline holds on the plotted values. Shaded bands are 95% bootstrap confidence intervals (2000 resamples of the problem set).
skyline against temperature
skyline = (total correct) / (total valid), pooled over problems — the accuracy ideal constrained generation reaches. It falls with temperature as the target π dilutes.
skyline by model and temperature
Each cell is the pooled skyline for one (model, temperature), greedy t=0 first, then the sampled temperatures. Browse the underlying rollouts in the explorer.
model
t=0.0
t=0.2
t=0.4
t=0.6
t=0.8
t=1.0
Llama-3 8B
0.465
0.447
0.427
0.390
0.341
0.309
Llama-3 8B Instruct
0.419
0.411
0.400
0.388
0.372
0.363
Llama-3.1 8B
0.405
0.399
0.385
0.354
0.316
0.279
Llama-3.1 8B Instruct
0.374
0.379
0.370
0.354
0.336
0.325
Llama-3.2 1B
0.128
0.114
0.101
0.088
0.067
0.050
Llama-3.2 1B Instruct
0.170
0.179
0.157
0.137
0.112
0.109
Qwen2.5-Coder 3B
0.452
0.432
0.403
0.362
0.318
0.295
Qwen2.5-Coder 3B Instruct
0.476
0.483
0.468
0.443
0.411
0.379
Qwen2.5-Coder 7B *
0.554
0.542
0.513
0.479
0.431
0.391
DeepSeek-Coder 6.7B *
0.426
0.431
0.419
0.392
0.350
0.295
Z, the acceptance rate (normalizing constant)
Z is the pooled proportion of rollouts that obey the constraint (run without error), Z = meanx Z(x) — the potential’s normalizing mass under the sampling distribution. With pooled estimators single-sample accuracy factorises as pass@1 = Z × skyline. Z collapses toward t=1.0 as more rollouts error out.
by library, choose a model
skyline and Z broken down by library for a single model. Use the selector to switch models; the two plots and the table below update together. Shaded bands are 95% bootstrap CIs (2000 resamples of that library’s problems).
skyline & Z by library and temperature (selected model):