SirRoboGarage/common_libs/tests/tm_pattern_sweep_results.md

TM pattern gun — discrete-target sweep results

Date: 2026-09-21. Author: background worker (executor-heavy). Artifacts implementing this: common_libs/guns/tm_pattern.nim, common_libs/tests/sweep_tm_pattern.nim. Do not commit.

What was built

tm_pattern.nim is a NEW gun (the old guns/tsetlin.nim is untouched). It attacks both the REPRESENTATION and the TARGET as the brief asked:

• Base: forecastLinear (the exact self-consistent forecast LinearGun uses). GF class 0 (centre) reproduces the Linear gun byte-for-byte, so any measured difference is attributable to the TM.
• Target: a discrete multi-class GUESS-FACTOR BUCKET — which lateral escape sector (in max-escape-angle units) the enemy occupied at the tick the bullet would have reached the BASE fire distance. 5 or 9 classes.
• Label: read from a per-tick ring of our own recorded enemy positions at the base arrival tick, NOT from FeedbackEvent.actualXY. Under the shipped bmPath metric actualXY is the closest-approach point on the gun's OWN aim ray, which biases the label toward the gun's own last output; the ring gives a clean, metric-independent label.
• Features: 40 hand-built binary/bucketed motion features (lateral-velocity sign over 3 ticks, turn-rate sign over 3 ticks, time since reversal, lateral magnitude, speed/distance/flight-time bands, four per-wall proximity bits, radial-fraction band, energy band, heading relative to LOS, approach sign).
• TM core: compact self-contained Granmo Table 2/3 with the corrected feedback rules and Eq. 6 empty-clause bootstrap (same corrected core as tsetlin.nim / tm_selector.nim, re-derived at 40-bit width).
• Per-enemy / freshness: a fresh net per gun instance; the net and history reset if the target id changes. Each offline round is replayed with a fresh instance (cold every battle, overfit within the battle).

Config overrides used in the final run: -d:TM_CONF_MARGIN_DEF=0.25 -d:TM_SHRINK_DEF=0.5 (confidence gate + shrink). Defaults are 0.0 / 1.0 (= raw argmax). Compile-time knobs: TM_CLASSES, TM_NCLAUSES, TM_NSTATES, TM_S_DEF, TM_MIN_OBS, TM_CONF_MARGIN_DEF, TM_SHRINK_DEF, TM_GF_MODE (hard|soft), TM_SOFT_BETA_DEF.

How to reproduce

nim c --path:common_libs -d:release \
    -d:TM_CONF_MARGIN_DEF=0.25 -d:TM_SHRINK_DEF=0.5 \
    -o:/tmp/sweep_tm_pattern common_libs/tests/sweep_tm_pattern.nim
/tmp/sweep_tm_pattern --set=real --seeds=3 --metric=path \
    --variants=linear,tsetlin,tmpat,tmpat_shuf
/tmp/sweep_tm_pattern --set=real --seeds=3 --metric=point \
    --variants=linear,tsetlin,tmpat,tmpat_shuf

Raw outputs: /tmp/final_path_s3.txt, /tmp/final_point_s3.txt, /tmp/final_ungated_path_s3.txt, /tmp/syn_*.

Metric

EARLY = resolutions in the first 100 ticks of each round (a cold TM every round). OVERALL = whole fixture. Pooled over all rounds / fixtures / seeds. TMPatternShuf = identical gun/encoding/cadence but the training label is a uniform-random class (the mandatory shuffled-feedback control). Per-run = one fixture × one seed (Linear is deterministic and replicated across seeds for pairing). Significance = exact two-sided paired sign test, 18 pairs.

The core result — the discrete target IS learnable, but does not beat the base

Online classification accuracy of the GF bucket (warm predictions only, seeds=1, n ≈ 1.26 M for each arm):

arm	correct/total	accuracy
TMPattern (real labels)	578722/1258488	46.0%
TMPatternShuf (random labels)	246733/1231116	20.0% (chance)

So the Tsetlin Machine genuinely learns the discrete target (2.3× chance). The representation mismatch was real and is fixed. The problem is that the target is not aligned with what wins the metric.

Real DrussGT fixtures, bmPath (shipped), seeds=3

variant	early	overall
Linear	34.0% (6358/18715)	24.3% (58297/239943)
Tsetlin (default)	22.3% (12344/55463)	20.3% (145828/719205)
TMPattern (gated)	27.9% (15514/55535)	22.0% (158658/719681)
TMPatternShuf	28.7% (16049/55969)	19.4% (139639/719790)

Paired sign tests (18 runs; ranges overlap, so the paired test is the test):

• Linear > TMPattern: early 15/18 p=0.0075; overall 15/18 p=0.0075. Significantly worse than Linear.
• TMPattern > TMPatternShuf: early 10/8 p=0.81 (tie); overall 17/1 p=0.0001. Learning is real but shows up mainly in the whole-round aggregate, not early.
• TMPattern > Tsetlin: early 17/1 p=0.0001; overall 12/6 p=0.24. Beats the default TM gun early, ties overall.

Per-run distributions (mean [min,max], 18 runs): Linear early 35.52 [26.03,50.55] / overall 26.86 [9.79,43.36]; Tsetlin 25.76 [19.79,47.68] / 21.99 [9.64,31.34]; TMPattern 31.18 [20.17,55.11] / 24.45 [11.24,37.78]; Shuf 31.42 [20.72,53.49] / 21.07 [9.55,32.65].

Raw ungated hard argmax (margin 0.0, shrink 1.0), bmPath, seeds=3

variant	early	overall
Linear	34.0%	24.3%
Tsetlin	22.3%	20.3%
TMPattern	21.2% (11783/55664)	18.6% (133465/719432)
TMPatternShuf	15.2% (8710/57169)	8.3% (59903/720583)

TMPattern > Shuf 18/18 p<0.0001 on BOTH early and overall; TMPattern < Linear 3/15 p=0.0075 on both. The raw classifier is a clear, decisive learner and a clear loser to the Linear base: applying an argmax GF bucket costs ~13 pp early.

Real DrussGT fixtures, bmPoint, seeds=3 (gated)

variant	early	overall
Linear	7.2% (1480/20498)	4.7% (11277/241423)
Tsetlin	7.0% (4403/62617)	4.8% (34588/724717)
TMPattern	7.2% (4441/61842)	4.6% (33341/724556)
TMPatternShuf	6.6% (4112/61979)	3.4% (24847/724655)

Online accuracy 50.8%. TMPattern is statistically indistinguishable from Linear here (early per-run mean 13.67 vs 13.61; overall 5.70 vs 5.77) and beats its control on overall — i.e. on the arrival-time metric the correction is neutral, not harmful.

Synthetic fixtures (known rules) — the mechanism works when motion is predictable

bmPath, seeds=1, soft readout K=9: Linear early 76.3% / overall 71.4%; TMPattern early 76.6% / overall 71.8%; Shuf early 76.6% / overall 67.8%. Per-fixture gains vs Linear: wall-bounce 567 vs 537, energy-threshold-turner 332 vs 319; loss: constant-velocity 417 vs 431.

bmPoint, seeds=1, gated hard K=5: Linear 66.4% / 59.6%; TMPattern 66.8% / 60.6%; Shuf 55.7% / 50.1%. Energy-threshold-turner 268 vs 212, wall-bounce 585 vs 573.

Verdict

• Learning: YES, decisively. The discrete-target TM predicts the GF bucket far above chance (46% vs 20%) and beats its shuffled control (ungated 18/18, p<0.0001). The "regression is a TM mismatch" diagnosis was correct.
• Beats Linear: NO on the real surfers under bmPath (significantly worse, p=0.0075). Neutral under bmPoint. Matches/slightly beats Linear only on synthetic motion whose future is genuinely predictable.
• Best configuration found: gated hard K=5, TM_CONF_MARGIN=0.25, TM_SHRINK=0.5 → 27.9% early / 22.0% overall (bmPath, real), +5.6 pp early / +1.7 pp overall vs the default TM gun, but 6.1 pp early / 2.3 pp overall behind Linear.

MEASURED vs INFERRED

MEASURED: every number in the tables above (pooled hits/shots, per-run distributions, paired sign tests, online classification accuracies). The position-ring label is our own recorded history at the base arrival tick; the shuffled control replaces only the label class with a uniform random draw.

INFERRED: that the residual loss on real surfers is because the linear lead is already the modal GF (label histogram is centred: real labels [3.8,6.6,17.6,6.6,3.5]×10⁵ for 5 classes) and the enemy's per-tick lateral reversal sign is not predictable enough from the 40 context bits to make a corrective excursion net-positive. Not directly measured.

What to try next (not done, time-boxed out)

1. Radial target instead of angular. forecastRadialBlend work showed the dominant surfer error is range-holding (radial), not angle. A TM classifier over a RADIAL displacement bucket applied as an aim-distance correction targets the error the base actually has room to fix, and should matter most under bmPoint.
2. Binary reversal with a two-candidate aim (brief candidate #1, unimplemented): predict "will the enemy reverse lateral direction before arrival?" and choose between the linear lead and a reversed lead. Same GF family, but a 2-class target is far more data-efficient; expected neutral given the GF result.
3. Condition a genuinely weaker base. The measured wall says the deficit is the baseline; the Linear base leaves the TM no headroom. Feeding the TM the residual of forecastRadialBlend (a base that is worse on straight-liners but range-correct on surfers) is where a learned correction could plausibly pay.
4. Richer context. 46% accuracy leaves room; the current context lacks the enemy's own recent GF history / segmentation that KNN/DecayGF exploit.

---

ROUND 2 — fix the base, then try a target Linear cannot predict

Date: 2026-09-22. Artifacts: common_libs/guns/tm_pattern.nim (extended), common_libs/tests/sweep_tm_pattern.nim (extended). Raw outputs: /tmp/tm2_real_path_s3.txt, /tmp/tm2_real_point_s3.txt, /tmp/tm_best_path_s3.txt. All numbers below are MEASURED unless a line says INFERRED.

Round 1's "best" gun predicted the LATERAL GF bucket. Round 2 adds a RADIAL head (aim-distance correction) and a binary REVERSAL head (flip the GF sign), both on the same 40-bit context and the same TM core, selected by a runtime targetMode (tmGF | tmRadial | tmReversal). The shuffled-feedback control now randomises only the head the active mode is claiming.

Task 1 — the base is EXACTLY Linear (premise refuted)

tm_pattern's base is forecastLinear, which already iterates the flight time (5-iteration fixed point, same as LinearGun). The only deviation from LinearGun was the wall clamp: the base path clamped to [BotRadius, W-BotRadius] (17 px inset) instead of LinearGun's [0, W]. Added a forceBase flag and a TMPatternBase variant, and made the zero-correction path return f.x, f.y with the exact [0, W] clamp.

Real DrussGT fixtures, bmPath, seeds=3, 18 fixture×seed runs, 77 rounds pooled:

variant	early	overall
Linear	34.0% (6358/18715)	24.3% (58297/239943)
LinearOldClamp (pre-fix base, BotRadius inset)	34.2% (6350/18592)	24.7% (59217/239891)
TMPatternBase (forceBase, exact Linear clamp)	34.0% (6358/18715)	24.3% (58297/239943)

Paired sign test Linear vs TMPatternBase: 18 ties, 0 wins each, p=1.000 on both early and overall; every per-run row (hits, shots, per-bin) is byte-for-byte identical. Per-run means identical: early 35.52%, overall 26.86%.

Verdict: the base was never behind. It IS LinearGun to the last floating point. The earlier "one-shot, non-iterating baseline" finding belonged to the OLD guns/tsetlin.nim, not to tm_pattern. The clamp fix is a wash (the old inset was marginally BETTER on overall: 24.7% vs 24.3%), so there is zero baseline headroom to recover: the entire deficit vs Linear is the TM's corrective excursions.

Task 2 — radial target: a structural no-op under bmPath, a real WIN under bmPoint

Structural fact (from virtual_bullets.nim, INFERRED then confirmed): under bmPath a bullet flies along the aim RAY until it leaves the arena; the aim distance only sets fireDist (used for the tie-break probe), it does NOT change the ray. Moving the aim point radially along the base bearing therefore cannot change a bmPath hit. Confirmed exactly: on the synthetic set, TMRadial vs Linear scored 8/8 exact ties, p=1.000 under bmPath.

Under bmPoint the bullet resolves when travelDist >= fireDist, so the aim distance selects the arrival tick — the radial degree of freedom is live.

bmPath (shipped), real, default config, seeds=3

variant	early	overall
Linear	34.0%	24.3%
TMRadial	33.9% (19038/56203)	24.1% (173577/719860)
TMRadialShuf	33.8% (18976/56085)	24.3% (175154/719781)

Per-run means (n=18): Linear 35.52/26.86; TMRadial 35.44/26.70; Shuf 35.40/26.92. Paired sign tests: Linear vs TMRadial early 13/5 p=0.096; overall 15/3 p=0.0075 (a tiny systematic LOSS, traceable to the BotRadius clamp perturbing the ray near walls when radOffset != 0). TMRadial vs TMRadialShuf early 8/8 p=1.000.

Verdict bmPath: no gain. Radial is a structural no-op; the shipped metric therefore cannot reward Task 2.

bmPoint, real, default config, seeds=3

variant	early	overall
Linear	7.2% (1480/20498)	4.7% (11277/241423)
Tsetlin (default gun)	7.0% (4403/62617)	4.8% (34588/724717)
TMRadial	9.4% (6013/63785)	5.8% (42079/726652)
TMRadialShuf (control)	7.0% (4329/61691)	3.6% (26116/724594)

Per-run means (n=18): Linear 13.61/5.77; Tsetlin 13.13/5.82; TMRadial 15.32/7.06; Shuf 12.86/4.34. Paired sign tests:

• TMRadial > Linear: early 14/4 p=0.0309; overall 17/1 p=0.0001.
• TMRadial > TMRadialShuf: early 17/1 p=0.0001; overall 18/0 p<0.0001.
• TMRadial > Tsetlin: early 17/1 p=0.0001; overall 15/3 p=0.0075.
• TMRadialShuf vs Linear: early 10/8 p=0.81; overall 12/6 p=0.24 (control sits at baseline).

Online accuracy of the radial head: 48.8% (511949/1049453) vs 19.9% shuffled chance under bmPoint (46.6% vs 20.0% under bmPath). Radial label histogram (raw, seeds=1) = [9058, 5392, 10305, 2236, 1112]: strongly asymmetric — surfers are often NEARER than the base constant-velocity prediction at the arrival tick (the base overshoots range on range-holders), so class 0 (aim 45–60 px short) dominates. That is the mechanism behind the win.

Caveat (MEASURED): labelMiss is much higher for radial mode (~4.3 M vs ~1.7 M for GF) because aiming SHORT resolves the bullet before the base arrival tick, so the arrival-tick ring sample is not yet recorded. The radial head is trained only on resolvable samples; the win is nonetheless measured on the metric, which is label-independent. A deferred-label fix would be the next refinement.

Task 3 — binary reversal: not learnable, and the flip is a no-op

Label: net heading turn over the flight opposes the direction the enemy was turning at fire time (threshold 10°). Readout: train GF as in round 1, and if reversal is predicted, negate the GF correction (TM_REV_GAIN=1.0).

Label base rate (real, seeds=1, 1 round/fixture): rev=[24772, 2673] → the positive class is only 9.7%. The head scores 86.8% (23030/26517) — below the 90.3% majority-class base rate, i.e. it is not detecting reversals at all, only predicting "no reversal". (The shuffled control is 50.2% because its labels are balanced.)

bmPath (shipped), real, default config, seeds=3

variant	early	overall
Linear	34.0%	24.3%
Tsetlin (round-1 measurement)	22.3%	20.3%
TMReversal	19.5% (11062/56704)	18.4% (132356/719725)
TMReversalShuf	19.1% (10925/57063)	17.8% (128450/720126)

Per-run means: TMReversal 23.45/20.32; Shuf 22.51/20.01. Paired: TMReversal vs Shuf early 12/6 p=0.238; overall 8/10 p=0.815 → no learning effect on hits.

bmPath, best config (margin=0.25, shrink=0.5), real, seeds=3

variant	early	overall
Linear	34.0%	24.3%
TMPattern (gated GF, round-1 best)	28.3% (15815/55902)	22.2% (159674/719742)
TMReversal (gated GF + flip)	28.4% (15944/56067)	22.3% (160163/719761)
TMReversalShuf	28.7% (16146/56195)	21.7% (155973/719841)

Paired: TMPattern vs TMReversal early 11/7 p=0.481, overall 7/11 p=0.481 — the flip changes nothing. TMReversal vs Shuf overall 13/5 p=0.096 (not significant).

Verdict: clean negative. The reversal target as defined is too rare to learn (head below the majority baseline), and using it to flip the GF sign is neutral to slightly negative on hits. Do not pursue this label; if revisited, balance the positive class (per-tick reversal events, or predict the arrival turn direction rather than "a reversal happened").

Round-2 overall verdict

• On bmPath (the shipped metric): the TM is NOT competitive with Linear. Base = Linear exactly; radial is a structural no-op; gated GF is significantly worse (28.3%/22.2% vs 34.0%/24.3%, p=0.0075); reversal does nothing. The linear lead is already the best aim DIRECTION on these surfers and every learned angular excursion loses.
• On bmPoint: the TM now BEATS Linear and the default Tsetlin gun. TMRadial (radial head, TM_RADIAL_RANGE=60, TM_RAD_MARGIN=0.25, 5 classes, gated), 9.4%/5.8% vs Linear 7.2%/4.7% (overall 17/1, p=0.0001) and vs Tsetlin 7.0%/4.8% (overall 15/3, p=0.0075), with its shuffled control at 7.0%/3.6%. This is the first configuration in the whole TM effort that beats both baselines with a control-validated margin.
• Learning vs controls: radial head 48.8% vs 19.9% chance (bmPoint); GF head reproduces round 1 (48.5% vs ~20%); reversal head does not beat majority.

Best configuration if the arrival-time metric is what matters: TMRadial. Best configuration under the shipped bmPath: do nothing — keep the Linear base. The evidence says the next step under bmPath is not another bucket target but either a richer DIRECTION representation (segmentation / pattern matching, as KNN and DecayGF use) or a metric that exposes the radial degree of freedom.

Per-enemy specialisation / freshness (MEASURED, unchanged from round 1): each offline round is replayed with a FRESH gun instance and the gun calls resetLearning if the target id changes mid-battle. The offline fixtures are single-target, so the mid-battle reset never fires there; its effect is untested by these numbers. There is no persistence across battles.

MEASURED vs INFERRED (round 2)

• MEASURED: every table, per-run mean, paired sign test, online accuracy, label base rate, and the exact TMPatternBase/Linear byte-for-byte identity.
• MEASURED: the bmPath radial no-op (synthetic exact ties; real bmPath tiny clamp-induced loss).
• INFERRED: that bmPath ignores radial distance because it flies a ray — read from virtual_bullets.nim, then confirmed by the synthetic tie.
• INFERRED: that the radial win comes from surfers being NEARER than the base prediction (range-holding), supported by the asymmetric radial label histogram but not separately modelled.

---

ROUND 3 — ABLATION: does the radial win even need the Tsetlin Machine?

Date: 2026-09-22. Artifacts: common_libs/guns/radial_offset.nim (new), common_libs/tests/sweep_radial_offset.nim (new), common_libs/guns/tm_pattern.nim (label/readout instrumentation only). Raw outputs: /tmp/ro_point_s3.txt, /tmp/ro_path_s3.txt (--set=real --seeds=3), /tmp/ro_point_s1.txt.

The question

Commit 589a230 retracted the radial head's "conditional learning" claim: the radial head's online accuracy (57.0%) is AT/BELOW the 58.2% majority baseline, and the bmPoint metric win was attributed to a NET-POSITIVE AVERAGE RADIAL SHIFT. If that is what it is, a FIXED radial shift should reproduce the win with no learning, no 0.36 ms/tick cost and no risk.

radial_offset.nim is exactly that fixed shift and nothing else: the exact forecastLinear bearing, aim distance f.dist * scale + offsetPx, and the SAME [BotRadius, arena-BotRadius] clamp the TM's corrective path uses. It is stateless, so two runs are identical by construction. The sweep runs Linear, a grid of constants, TMRadial and TMRadialShuf under BOTH metrics, using the identical fixture set / round splitting / per-fixture fresh gun methodology as sweep_tm_pattern.nim.

Harness sanity check (MEASURED): TMRadial in this report reproduces the committed numbers exactly — bmPoint early 9.1% / overall 5.7%, vs Linear early 16/2 p=0.0013 and overall 18/0 p<0.0001, vs Shuf 18/0 p<0.0001. So the ablation runs on the same experiment, not a re-derivation.

0 dropped bullets in every run (ring never clobbered); labelMiss=0 and traceMiss=0 for every TM row (the deferred-label fix holds).

bmPoint (seeds=3)

Pooled over 77 rounds for the deterministic arms (one pass; replicated across the 3 seeds only for the paired test) and 231 rounds for the TM arms (3 seeds).

variant	early	overall
Linear	7.2% (1480/20498)	4.7% (11277/241423)
RO_s1.00 (base + BotRadius clamp only)	7.2% (1481/20626)	4.7% (11388/241551)
RO_s0.98 (scale 0.98)	8.0% (1669/20781)	5.8% (14033/241677)
RO_s0.95	8.8% (1852/21001)	6.3% (15299/241890)
RO_o-10 (fixed -10 px)	8.4% (1756/20790)	5.9% (14336/241689)
RO_o-20	7.9% (1658/20939)	6.4% (15445/241836)
RO_o-30	5.4% (1130/21117)	4.9% (11740/242007)
RO_o-40	4.1% (883/21292)	3.7% (8989/242166)
RO_o-60	4.7% (1019/21655)	3.0% (7173/242495)
RO_o+30 (opposite-direction control)	0.6% (131/20159)	0.3% (650/241168)
TMRadial	9.1% (5776/63518)	5.7% (41232/726357)
TMRadialShuf	7.0% (4314/61672)	3.8% (27317/724473)

Per-run means over the 18 fixture×seed runs: Linear 13.61 / 5.77; RO_s0.95 14.86 / 7.47; RO_o-20 10.35 / 7.45; TMRadial 15.08 / 6.89; Shuf 12.89 / 4.54.

Paired sign tests (exact two-sided binomial, 18 pairs):

A	B	metric	nA>B	nB>A	p
RO_s0.95	Linear	early	15	3	0.0075
RO_s0.95	Linear	overall	15	3	0.0075
RO_s0.98	Linear	overall	18	0	<0.0001
RO_o-20	Linear	early	15	3	0.0075
RO_o-20	Linear	overall	15	3	0.0075
RO_o-10	Linear	overall	18	0	<0.0001
RO_o+30	Linear	both	0	18	<0.0001 (wrong direction)
TMRadial	Linear	early	16	2	0.0013
TMRadial	Linear	overall	18	0	<0.0001
TMRadial	Shuf	both	18	0	<0.0001
RO_s0.95	TMRadial	early	9	9	1.0000 (tie)
RO_s0.95	TMRadial	overall	15	3	0.0075 (constant wins)
RO_o-20	TMRadial	early	6	12	0.2379
RO_o-20	TMRadial	overall	12	6	0.2379
RO_s0.98	TMRadial	overall	6	12	0.2379

MEASURED conclusion (bmPoint): a constant radial shift of scale 0.95 (or fixed −20 px) ties the learned radial head on EARLY and beats it on OVERALL (7.47% vs 6.89% per-run mean, 15/3 p=0.0075). The learned head's whole nominal advantage is its slightly higher early rate (9.1% vs 8.8% pooled, 15.08% vs 14.86% per-run), and that is a statistical tie (9/9, p=1.0). RO_o+30 (aiming the opposite way) collapses to 0.3%, confirming the direction of the effect is real and not a clamp artefact.

bmPath (the SHIPPED metric) — the radial avenue is a dead end

variant	early	overall
Linear	34.0% (6358/18715)	24.3% (58297/239943)
RO_s1.00 (clamp only)	34.2% (6350/18592)	24.7% (59217/239891)
RO_s0.98	34.2% (6360/18623)	24.6% (58950/239906)
RO_s0.95 (best bmPoint constant)	34.0% (6344/18675)	24.4% (58530/239937)
RO_o-20 (best bmPoint constant)	34.1% (6354/18649)	24.5% (58699/239921)
RO_o+30 (best bmPath constant)	34.4% (6357/18498)	24.8% (59366/239852)
RO_s0.80	33.6% (6346/18886)	23.4% (56151/240035)
TMRadial	33.8% (19002/56211)	24.0% (173001/719875)
TMRadialShuf	33.9% (19026/56076)	24.3% (175262/719776)

Per-run means (n=18): Linear 35.52 / 26.86; RO_s1.00 35.71 / 27.23; RO_s0.95 35.59 / 26.97; RO_o-20 35.63 / 27.04; TMRadial 35.37 / 26.63 (a loss).

Paired sign tests (bmPath):

• TMRadial vs Linear: early 5/13 p=0.0963; overall 2/16 p=0.0013 — a systematic LOSS. (Matches the committed Round-2 finding.)
• RO_s1.00 vs Linear: overall 18/0 p<0.0001 (+0.4 pp) — this is the pre-existing BotRadius-clamp effect, not the radial shift.
• Every constant between 0.98 and 0.95 and every fixed offset −10..−20 is within ±0.2 pp of Linear; RO_s0.95 (a real +1.6 pp win on bmPoint overall) is only +0.1 pp here and below the clamp-only arm. Strong shrink (≤0.90, ≤−40 px) is a significant loss (e.g. RO_s0.80 3/15 p=0.0075 early, 0/18 overall).
• RO_o+30 — the OPPOSITE direction to what bmPoint wants — is the best bmPath constant (+0.5 pp, 18/0). So the bmPath response to the radial knob is clamp-mediated and direction-insensitive, i.e. the radial degree of freedom is a structural no-op, exactly as Round 2 argued.

MEASURED conclusion (bmPath): neither the learned radial head nor any constant reproduces a real gain. TMRadial is a systematic loss. The whole radial avenue cannot help the shipped configuration.

The radial-label distribution (MEASURED)

Pooled TMRadial training labels (3 seeds, n=725997), class centres −60/−30/0/+30/+60 px: radLabelHist = [415166, 126461, 120325, 44694, 19351] → majority class 57.2%, meanRadDelta = −82.30 px, meanAbsRadDelta = 90.13 px. The head's online accuracy is 56.2%, i.e. at/below that majority. The mean APPLIED shift is −37.61 px (radChosenHist = [460960, 35411, 249071, 6832, 2994]).

Metric-free raw base radial error (each fired bullet's enemy radius minus forecastLinear's fire distance, at the base arrival tick):

fixture	n	mean px	meanAbs px	frac nearer	frac farther
drussgt_vs_crazy	35959	−87.6	92.7	0.693	0.053
drussgt_vs_spinbot	19830	−100.4	107.7	0.769	0.062
drussgt_vs_drussgt	26060	−70.8	85.8	0.627	0.142
tr_drussgt_vs_crazy	45905	−99.0	104.4	0.805	0.053
tr_drussgt_vs_spinbot	43150	−92.4	96.7	0.793	0.044
tr_drussgt_vs_modularbot	79970	−79.9	90.7	0.705	0.108

The enemy is NEARER than the constant-velocity prediction in 63–81% of fired bullets and FARTHER in only 4–14%, consistently across all six captures and both metrics. So the net-short bias is a GENUINE property of these range-holding surfers against the constant-velocity base (the base lets range grow geometrically; they hold it) — not a one-fixture artefact.

INFERRED: the mean label (−82 px) is much larger than the OPTIMAL constant shift (−20 px). The mean is dominated by large radial errors that miss regardless of the shift; the near-miss window is served better by a small shift, and a larger shift also resolves the bullet at an earlier tick. The exact reason a −20 px shift beats −60 px is not separately modelled.

Does the optimal constant vary by adversary? (MEASURED)

bmPoint, best constant PER FIXTURE (in-sample upper bound), with Linear and TMRadial for reference:

fixture	best early	best overall	Linear overall	TMRadial overall
drussgt_vs_crazy	RO_s0.80 (10.1%)	RO_o-10 (16.9%)	15.8%	17.0%
drussgt_vs_spinbot	RO_s0.95 (9.9%)	RO_s0.95 (11.5%)	7.5%	9.9%
drussgt_vs_drussgt	RO_s1.00 (55.3%)	RO_s0.98 (4.3%)	3.9%	4.1%
tr_drussgt_vs_crazy	RO_s0.85 (9.5%)	RO_o-30 (5.8%)	2.9%	4.4%
tr_drussgt_vs_modularbot	RO_s0.95 (6.8%)	RO_s0.95 (2.7%)	1.3%	2.1%
tr_drussgt_vs_spinbot	RO_s0.80 (6.8%)	RO_s0.95 (7.4%)	3.3%	3.7%

MEASURED: the per-fixture optimum DOES vary (fixed −10 for crazy, −30 for tr_crazy, scale 0.95 for three others). But one GLOBAL constant (0.95) still beats TMRadial on pooled and per-run overall bmPoint. So the per-adversary variation is not enough to justify the learned head: a fixed 0.95 is already the best pooled point-metric arm measured here.

DIRECT VERDICT

1. bmPoint: REPLACE the radial TM with a constant. The best constant (scale 0.95, equivalently fixed −20 px) statistically TIES the TM on early (9/9 p=1.0) and BEATS it on overall (15/3 p=0.0075; 7.47% vs 6.89% per-run mean). The head never out-classifies its majority baseline (56.2% vs 57.2%) and its mean applied shift (−37.6 px) is roughly twice the optimal constant. The TM buys nothing a constant does not, and costs 0.36 ms/tick + complexity.
2. bmPath (shipped): DEAD END. No constant and no TM improves it; TMRadial is a systematic loss (2/16 p=0.0013), and the only real bmPath effect in the table is the BotRadius clamp, which is direction-insensitive. Drop the radial mode from any shipped configuration.
3. Fragility argument fails. The optimum does vary per adversary, but a single global constant already matches/beats the adaptively-trained head — so the TM is not earning its cost even by the "per-adversary adaptation" argument (it is cold-every-battle and trains online within the battle, yet still loses to the global 0.95).

Net: do not keep the radial TM. If the arrival metric ever matters, ship the stateless constant; for the current shipped metric, the radial mode (and its registered gun id 14) is not justified.

MEASURED vs INFERRED (round 3)

• MEASURED: every table, pooled rate, per-run mean, paired sign test, label histogram, mean/abs radial delta, applied-shift mean, online accuracy, and the exact reproduction of the committed TMRadial numbers.
• MEASURED: the constant-offset arm is stateless (verbatim forecastLinear bearing, f.dist*scale+offsetPx, TM corrective clamp), so its rollout is deterministic and its replicated per-seed values are legitimate.
• MEASURED: RO_s1.00 isolates the BotRadius clamp — on bmPoint it is identical to Linear (7.2/4.7%), on bmPath it is the +0.4 pp arm; the radial shift itself adds nothing on bmPath.
• INFERRED: the explanation of the label-mean (−82 px) vs optimal shift (−20 px) gap (large-error tail + earlier resolution tick); the direction claim itself is measured (the +30 control collapses).
• INFERRED (not measured): whether a per-adversary constant would beat a global one out-of-sample — the per-fixture optima above are in-sample.

How to reproduce (round 3)

nim c --path:common_libs -d:release -o:/tmp/sweep_radial_offset \
    common_libs/tests/sweep_radial_offset.nim
/tmp/sweep_radial_offset --set=real --metric=point --seeds=3
/tmp/sweep_radial_offset --set=real --metric=path  --seeds=3
# smoke: --seeds=1