Course log · seed 90051 · 20,000 matched rounds

The 2023 results, reproduced

The original notebook printed one average reward per algorithm and plotted 10-repeat curves. Re-running it unchanged and replaying the TypeScript port from the exact same random-number state gives the same numbers to the last digit. Stepping through those runs also shows why they came out the way they did.

Evaluation (a): one run each

SESuccessive Elimination
Pareto delays (arms 2 & 5 heavy-tailed)
Printed in 2023
0.38145
TypeScript port
0.38145
vs best arm
75%
10-repeat final
0.3763
PSEPhased Successive Elimination
Packet loss (90% on arm 2)
Printed in 2023
0.30405
TypeScript port
0.30405
vs best arm
60%
10-repeat final
0.2843
OPSEOptimistic-Pessimistic SE
Reward-dependent (1,000-round lag)
Printed in 2023
0.2184
TypeScript port
0.2184
vs best arm
43%
10-repeat final
0.2144
TSThompson Sampling
No delay
Printed in 2023
0.4218
TypeScript port
0.4218
vs best arm
83%
10-repeat final
0.2203
DATSDoubly-Adaptive Thompson Sampling
No delay
Printed in 2023
0.24495
TypeScript port
0.24495
vs best arm
48%
10-repeat final
0.2526

Average reward per algorithm as printed in 2023 and as reproduced by the port
Algorithm	Delay setting	Printed in 2023	TypeScript port	vs best arm	10-repeat final
SESuccessive Elimination	Pareto delays (arms 2 & 5 heavy-tailed)	0.38145	0.38145	75%	0.3763
PSEPhased Successive Elimination	Packet loss (90% on arm 2)	0.30405	0.30405	60%	0.2843
OPSEOptimistic-Pessimistic SE	Reward-dependent (1,000-round lag)	0.2184	0.2184	43%	0.2144
TSThompson Sampling	No delay	0.4218	0.4218	83%	0.2203
DATSDoubly-Adaptive Thompson Sampling	No delay	0.24495	0.24495	48%	0.2526

Always playing the best arm (arm 2) would average 0.5092; the log as a whole averages 0.2229. The recorded Python re-run of the whole notebook took 17 min 33 s; the TypeScript port replays all five single runs in a few seconds.

Evaluation (b)

Cumulative average reward over 10 repeats

Each curve averages ten fresh bandits that share one generator, exactly as the notebook's helper did. The dashed line is the best arm; the log as a whole averages 0.223. The TS curve is not the TS above: the helper passed the horizon into TS's prior-mean argument (see below).

SE
PSE
OPSE
TS
DATS

Data table

Cumulative average reward averaged over 10 repeats, as computed by the 2023 notebook on the course log
Matched round	SE	PSE	OPSE	TS	DATS
100	0.23	0.26	0.34	0.24	0.26
2,100	0.22	0.23	0.22	0.22	0.25
4,100	0.23	0.22	0.22	0.22	0.25
6,100	0.25	0.23	0.21	0.22	0.25
8,100	0.27	0.23	0.21	0.22	0.25
10,100	0.29	0.23	0.21	0.22	0.25
12,000	0.31	0.24	0.21	0.22	0.25
14,000	0.33	0.26	0.21	0.22	0.25
16,000	0.35	0.27	0.22	0.22	0.25
18,000	0.36	0.28	0.21	0.22	0.25
20,000	0.38	0.28	0.21	0.22	0.25

Replaying the runs step by step

What the port uncovered

SE paid for exploration, then locked on

Under heavy-tailed delays SE eliminated arms 6, 9, 0, 3, 4, 5, 8, 1 and finally 7 (internal round 15,767). The notebook's own elimination log misses arm 0, because its np.any check tests arm indices. Arm 2 alone survived and took 43% of all pulls; the remaining gap to 0.509 is the cost of round-robin exploration while arm 2's own feedback was among the slowest to arrive.

SE pulls per arm on the course log
arm 0	436
arm 1	1729
arm 2	8520
arm 3	573
arm 4	816
arm 5	1385
arm 6	269
arm 7	4294
arm 8	1663
arm 9	315

PSE

PSE survived 90% packet loss on the best arm

45,711 feedback events were lost, yet PSE never eliminated arm 2. It ended in phase 3 with arms 2 and 7 active, yet split its pulls evenly between arms 1, 2, 7 and 8: all four entered phase 3 together and none reached that phase's ≈4,400-observation threshold.

PSE pulls per arm on the course log
arm 0	1102
arm 1	3559
arm 2	3535
arm 3	1102
arm 4	1102
arm 5	1102
arm 6	276
arm 7	3561
arm 8	3559
arm 9	1102

OPSE

OPSE eliminated nothing

Pull counts grow on every logged event while observations grow only on matches, so the optimistic upper bounds never fell below anyone's lower bound. Pulls stayed flat (1,922–2,055 per arm) and the reward tracks the log average.

OPSE pulls per arm on the course log
arm 0	1922
arm 1	2055
arm 2	2010
arm 3	1994
arm 4	1968
arm 5	2016
arm 6	2030
arm 7	1962
arm 8	2020
arm 9	2023

TS won, and the 10-repeat curve is a different TS

The single run played arm 2 in 69% of rounds for 0.4218, the best of the five. The repeat helper called TS(n_arms, n_rounds, rng=rng), so μ₀ became 20,000 in an integer array; that curve sits near 0.22.

TS pulls per arm on the course log
arm 0	508
arm 1	777
arm 2	13743
arm 3	526
arm 4	600
arm 5	814
arm 6	395
arm 7	1336
arm 8	852
arm 9	449

Decision record · ADR-002

Why DATS (0.245) trails plain TS (0.422)

What happened. DATS deactivated arms 4, 2, 5, 1 and 3 by its 854th round, including arm 2, the best. Its play() then returned a position in the active-arm list rather than an arm id, so with five arms left it chose among arms 0–4: 99.0% of its pulls went there. A uniform mix of arms 0–4 earns 0.2442, essentially the 0.245 the notebook printed.

Contributing quirks. The arm with the fewest multinomial draws is chosen; propensities are proportional to the index of each arm's largest Monte Carlo sample; every arm's pseudo-rewards reuse the reward just observed; pulls are counted twice.

Decision. Keep the faithful port. The revival documents what was submitted, and the parity tests pin these numbers down. A corrected DATS would be a new, clearly labelled contestant, not a silent fix.

2026 follow-up. An ablation over 20 seeds corrects one quirk at a time and measures each step with a paired interval. Read DR-003 or see it on the uncertainty page.

DATS pulls per arm on the course log
arm 0	4043
arm 1	3988
arm 2	3932
arm 3	3868
arm 4	3974
arm 5	127
arm 6	45
arm 7	18
arm 8	4
arm 9	1

DATS pulls per arm. Faded arms were eliminated; most pulls still landed on arms 0–4.

Method

How “digit for digit” was achieved

Bandits branch on random draws and on ties, so approximate random numbers would send a port down a different path within a few rounds. Instead, the port reproduces numpy's generator exactly and starts from the state the notebook was in.

1
Re-run the original
A script executes the unchanged notebook cells (Python 3.13.9, NumPy 2.5.3, SciPy 1.18.1, arm64) and saves only numbers: the generator state before each evaluation, averages, curve checkpoints and per-arm aggregates.
2
Port the generator
SeedSequence, PCG64 (with a tiny WebAssembly core), Lemire bounded integers, choice, the 256-layer ziggurat normal, binomial inversion and multinomial, SciPy's Pareto and Bernoulli samplers, numpy's pairwise summation and argmax rules.
3
Match the floating point
numpy's Apple-silicon build fuses loc + scale·z into one rounding; the port emulates that fma. An x86-64 numpy rounds twice, which can flip a last bit and, through argmax ties, occasionally a choice.
4
Test it
Vitest replays every evaluation cell from its recorded state and requires exact equality, plus checkpoints of the 10-repeat curves. The course log stays in the repository for these tests and is never shipped to the site.

Try the 2023 setup in the lab Read the algorithm notes

Evaluation (a): one run each

Cumulative average reward over 10 repeats

What the port uncovered

SE paid for exploration, then locked on

PSE survived 90% packet loss on the best arm

OPSE eliminated nothing

TS won, and the 10-repeat curve is a different TS

Why DATS (0.245) trails plain TS (0.422)

How “digit for digit” was achieved

Re-run the original

Port the generator

Match the floating point

Test it