P6: document LTS/LTSLA non-comparability in README, add BLER accounting + diagnostic

README.md: add a compact P6-vs-P4-LTS section (algorithm-structure diff,
feedback-path diff, experimental-axis diff) cross-referenced from P4
Investigation 3's LTS bullet, so the non-comparability documented in
P6_reaudit_status.md SS3 is visible from the reader-facing doc, not just
the status doc. docs/index.html has the same gap (mentions LTS and LTSLA
in separate cards with no relationship noted) but was left unedited per
scope -- flagged for a future pass.

Adds a mean-BLER column to P6RLRunner's campaign CSV (additive only: the
per-TTI BLER value was already computed for the ACK/NACK draw in both
_run_olla and _run_rl, just never accumulated or returned). Verified
purely additive via full test suite (235 passed) and a sanity-check
re-run of an already-committed cell (seed=42, 30km/h, CDL-A, LTSLA)
matching the 81c76bb dataset to within floating-point noise.

Diagnostic re-run (same 5 seeds, N_TTIS=30000, full 6-config grid) finds
two distinct failure modes behind the 81c76bb throughput results: RLLA's
BLER runs at 0.13-0.17x the 10% target at every config (over-conservative
MCS, not a reliability problem); LTSLA's BLER matches OLLA's at 3 km/h
(a genuine efficiency win, matching its positive gain there) but runs at
1.57-2.07x target at 30/120 km/h (aggressive MCS failing to track faster
fading, matching its negative gain there). OLLA itself regulates to
0.99-1.01x target throughout, confirming it as a valid baseline.

Author: karrthikmohank

README.md

@@ -333,7 +333,7 @@ investigated further.
 **Investigation 3 — closed-loop controllers.** Benchmarks four closed-loop learned controllers against OLLA under matched conditions across 6 feedback-impairment conditions (idealized, quantization, report period, noise, delay, ACK/NACK error) to test robustness under realistic feedback, not just idealized performance — a decomposition none of the four cited papers tested, so large divergence from each paper's own headline number is expected (see the algorithms doc for why, per arm):
 
 - **SALAD** (Wiesmayr et al., arXiv:2510.05784) — tracks a running SINR estimate nudged by ACK/NACK "surprise" (a cross-entropy gradient step), with a probing mechanism for fast recovery from underestimation. Two modes: **c1c-agn** ignores CQI entirely after the first slot; **c1c-cqi** treats its estimate as a correction on top of each fresh CQI report.
-- **LTS** (Saxena, Tullberg, Jaldén, IEEE TWC 2022 / arXiv:2010.08651) — **c1b**: tracks a full Bayesian probability distribution over SINR (not a point estimate), Doppler-relaxed every TTI, with a pessimistic point estimate for MCS selection.
+- **LTS** (Saxena, Tullberg, Jaldén, IEEE TWC 2022 / arXiv:2010.08651) — **c1b**: tracks a full Bayesian probability distribution over SINR (not a point estimate), Doppler-relaxed every TTI, with a pessimistic point estimate for MCS selection. Not the same algorithm as P6's similarly-named LTSLA, and not directly comparable to it — see [P6 vs P4's LTS](#p6-vs-p4s-lts-not-the-same-algorithm-not-directly-comparable) below P6's section.
 - **BayesLA** (Saxena & Jaldén, SPAWC 2020) — **c1**: Thompson-sampled Beta posteriors over per-(MCS, CQI) success probability, feeding a throughput-maximizing LP under the BLER constraint.
 - **PPO / LOLLA-style residual** (Wang et al., arXiv:2606.23110) — **c2**: a live-trained neural policy outputs a continuous SINR correction on top of the standard MCS table, with a Lagrangian dual variable auto-tuning the NACK penalty to the BLER target.
 
@@ -486,6 +486,38 @@ python examples/run_p6_rl.py --mode campaign \
     --config examples/campaigns/p6_rl_link_adapt/rl_campaign.yaml --plot
 ```
 
+#### P6 vs P4's LTS: not the same algorithm, not directly comparable
+
+P4 Investigation 3's **LTS** (`c1b`) and P6's **LTSLA** share a name lineage
+(both cite the Saxena/Tullberg/Jaldén paper) but are neither the same
+implementation nor comparable results:
+
+- **Different mechanics.** P4's LTS maintains a discrete 184-bin PMF over a
+  SINR grid, uses a pessimistic point estimate (`min(sample, E[PMF])`), a
+  full-PMF Bayesian likelihood update, and a Gaussian-kernel relaxation
+  applied every TTI (`projects/p4_ml_link_adapt/lts.py`). P6's LTSLA
+  instead maintains a single Gaussian posterior, samples from it directly
+  (Thompson sampling), and updates via a scalar Kalman-style gain with
+  Doppler-based variance inflation (`projects/p6_rl_link_adapt/rl_core.py`).
+  Different update math, not the same algorithm under different names.
+- **Feedback path — the substantive difference.** P4's LTS is routed
+  through `feedback.py`'s impairment front end and sees degraded SINR
+  under 5 of P4 Investigation 3's 6 conditions. P6's LTSLA (and its OLLA
+  and RLLA baselines) never routes through any feedback-impairment model —
+  every P6 arm always sees true, instantaneous `ue.current_sinr_db`. P6's
+  results above, including the multi-seed headline, should be read as
+  measured **under genie/unimpaired feedback** — this condition is not
+  stated anywhere else in this section.
+- **Different experimental axis.** P4 Investigation 3 fixes mobility
+  (30 km/h, CDL-A) and sweeps feedback-impairment knobs; P6 fixes feedback
+  (idealized) and sweeps mobility/CDL. Neither is a superset or
+  replication of the other.
+- **Conclusion:** the two projects' results are not directly comparable,
+  and neither should be cited as validating or contradicting the other.
+
+Full algorithm-line-by-line comparison and re-verification:
+[`docs/redesign/P6_reaudit_status.md`](docs/redesign/P6_reaudit_status.md) §3.
+
 ---
 
 ## 3GPP compliance

docs/redesign/P6_reaudit_status.md

@@ -477,20 +477,21 @@ isolation study (unlike the P1–P4 RNG-decoupling audits).
 
 ### 7.2 STOP-condition check
 
-- **Realized BLER vs. 10% target**: **cannot be directly verified from
-  committed data.** `P6RLRunner`'s CSV schema (`FIELDNAMES` in `runner.py`)
-  has never included a BLER column — not for the original campaign, the
-  interim-corrected one, or this run. This is a pre-existing gap in the
-  runner's own metrics collection, not something introduced or fixed here
-  (adding BLER tracking would be a code change to `runner.py`, out of
-  scope for this task). Noted plainly rather than silently treated as
-  checked. As partial, indirect assurance: both `_best_mcs_for_sinr`
-  (`rl_core.py`, used by `ThompsonSamplingLA`) and `EpsilonGreedyRLLA`'s
-  own selection rule enforce a `target_bler=NRConstants.TARGET_BLER`
-  feasibility constraint by construction, and OLLA (via P3's
-  `LinkAdaptationManager`) is designed to converge to the same 10% target
-  — a structural reason to expect BLER near target, not a substitute for
-  a measurement.
+- **Realized BLER vs. 10% target**: **could not be directly verified from
+  committed data at the time this section was drafted.** `P6RLRunner`'s CSV
+  schema (`FIELDNAMES` in `runner.py`) had never included a BLER column —
+  not for the original campaign, the interim-corrected one, or this run.
+  This was a pre-existing gap in the runner's own metrics collection, not
+  introduced by this task. **Update (§8, same document, later session):**
+  a BLER column was subsequently added (additive-only change, sanity-check
+  verified) and a diagnostic re-run covering this exact grid (5 seeds × 6
+  configs × 3 arms, N_TTIS=30000) was completed — see §8 for the full
+  table and mechanism finding. This resolves the check for P6's own grid;
+  it does not retroactively add a BLER column to the `81c76bb` CSVs
+  themselves (a separate, parallel diagnostic dataset was used instead),
+  and it does not resolve the equivalent gap for any other project's
+  committed data (P1–P5, P4's Investigations 2/3, etc.), which still has
+  no BLER-vs-target verification performed as part of this series.
 - **Cross-seed consistency (sign-flip check)**: no bug-like inconsistency
   found. RLLA is negative in all 5 seeds × 6 configs (30/30 cells,
   −22.6% to −52.7%) — completely consistent direction. LTSLA is
@@ -617,3 +618,161 @@ Full per-row data: `results/P6_rl_campaign_results_seed{42,123,7,99,2024}_30ktti
 | Grid source | `examples/campaigns/p6_rl_link_adapt/rl_campaign.yaml` |
 | HEAD for this campaign | `4575a10b2284b0ef9ca84122f837051d06efa8a3` (reconfirmed unchanged) |
 | This section | Drafted 2026-07-18, same session as the campaign run |
+
+## 8. BLER diagnostic — is RLLA/LTSLA's gain-vs-OLLA reliability-driven or something else?
+
+Continues §7 (same commit lineage, `81c76bb`), separate working session.
+Goal: determine whether RLLA's −37.40% collapse and LTSLA's 30/120 km/h
+underperformance (§7.3–7.4) are BLER-driven (MCS selection pushing
+realized BLER far past the ~10% target) or something else (e.g.
+persistently over-conservative MCS with BLER well under target).
+
+### 8.1 Schema addition — additive-only, verified
+
+Per-TTI realized BLER was already computed in both simulation loops —
+`projects/p6_rl_link_adapt/runner.py`, `_run_olla` (`bler =
+NRConstants.sinr_to_bler(ue.current_sinr_db, mcs)`, previously line 77)
+and `_run_rl` (same call, previously line 107) — it was simply discarded
+after the `is_ack` draw, never accumulated or returned.
+
+**Change made**: both functions now also accumulate `total_bler += bler`
+each scheduled transmission and return `(mean_tp, mean_bler)` instead of
+just `mean_tp`. `P6RLRunner._row` and `FIELDNAMES` gained one new column,
+`mean_bler`. `P6RLRunner.run()` was updated to unpack and pass through the
+new tuple. **No line inside either simulation loop that affects `mcs`,
+`is_ack`, `ctrl.update`/`lam.update`, scheduling, or RNG consumption order
+was touched** — the only addition is a running sum of a value that was
+already being computed. Two call sites outside `runner.py` that call
+`_run_olla`/`_run_rl` directly needed matching updates to unpack the new
+tuple (not simulation-logic changes, just consuming the new return shape):
+`examples/run_p6_rl.py`'s `run_demo`, and
+`tests/test_projects.py::TestRLLinkAdapt::test_controller_reproducible_same_seed`.
+Full test suite re-run after the change: **235 passed, 0 failed** (same
+count as before this change).
+
+**Sanity-check reproduction** (seed=42, 30 km/h, CDL-A, LTSLA — an
+already-covered cell from the committed `81c76bb` dataset): re-running
+with the new code gave `system_tp_mbps=16.8471`, `gain_vs_olla_pct=-9.91`
+against the committed CSV's `16.8471` / `-9.91`
+(`results/P6_rl_campaign_results_seed42_30ktti.csv`, row
+`P6_ltsla,10,30,A,30000,16.8471,1.6847,-9.91`) — throughput matched to
+0.000034 Mbps and gain matched to 0.0019pp, both within floating-point/
+rounding noise from the CSV's own 4-decimal rounding. Confirms the schema
+addition did not alter simulation behavior.
+
+### 8.2 Diagnostic re-run
+
+Same 5 seeds as the committed campaign (`42, 123, 7, 99, 2024`),
+N_TTIS=30000 — directly comparable to `81c76bb`'s dataset, not a fresh
+independent sample. **Scope**: all 6 configs × all 3 arms (OLLA, RLLA,
+LTSLA). The task scoped LTSLA's required set to the 4 unfavorable configs
+(30/120 km/h × CDL-A/C) with the 2 favorable (3 km/h) configs optional;
+**both were included** — OLLA and RLLA already needed the full 6-config
+grid (RLLA was negative in all 30 §7 cells, no config excludable; OLLA is
+needed as the baseline at every config RLLA/LTSLA run at), so extending
+LTSLA to the same 6 configs cost no extra OLLA runs and gave a complete
+BLER picture of P6's entire committed grid for negligible extra time
+(~130s of the total 549.6s run).
+
+Stored as `results/P6_bler_diagnostic_seed{42,123,7,99,2024}_30ktti.csv`
+(5 files, 19 lines each — 1 header + 18 rows) — a separate, clearly-named
+diagnostic dataset, **not merged into or overwriting** the `81c76bb`
+campaign CSVs.
+
+### 8.3 Results — mean realized BLER per config (n=5 seeds)
+
+| Speed | CDL | OLLA mean BLER | OLLA std | RLLA mean BLER | RLLA std | RLLA vs. 10% target | LTSLA mean BLER | LTSLA std | LTSLA vs. 10% target |
+|---|---|---|---|---|---|---|---|---|---|
+| 3 km/h | A | 0.0985 | 0.0017 | 0.0143 | 0.0020 | 0.14× | 0.1020 | 0.0083 | 1.02× |
+| 3 km/h | C | 0.0985 | 0.0045 | 0.0126 | 0.0022 | 0.13× | 0.0901 | 0.0118 | 0.90× |
+| 30 km/h | A | 0.1011 | 0.0010 | 0.0159 | 0.0020 | 0.16× | **0.1880** | 0.0049 | **1.88×** |
+| 30 km/h | C | 0.1011 | 0.0015 | 0.0136 | 0.0021 | 0.14× | 0.1566 | 0.0086 | 1.57× |
+| 120 km/h | A | 0.1004 | 0.0013 | 0.0173 | 0.0017 | 0.17× | **0.2073** | 0.0052 | **2.07×** |
+| 120 km/h | C | 0.1005 | 0.0014 | 0.0147 | 0.0025 | 0.15× | 0.1739 | 0.0074 | 1.74× |
+
+(Full per-seed BLER values for every cell are in the committed diagnostic
+CSVs; not hand-transcribed here to avoid drift from the data.)
+
+**OLLA**: BLER is 0.99×–1.01× of the 10% target at every config, every
+seed (std ≤0.0045) — confirms OLLA is regulating to its design target
+consistently, and validates it as a baseline for the comparisons below.
+
+### 8.4 Mechanism finding — different failure mode per arm, stated per config as instructed
+
+**RLLA: mechanism (b), overly conservative — BLER far under target at
+every config.** RLLA's realized BLER is 0.13×–0.17× of the 10% target
+(1.3%–1.7% absolute) at all 6 configs, all 5 seeds — no config comes
+close to the target, let alone exceeds it. This is not a reliability
+failure: RLLA is not decoding badly, it is choosing MCS indices far more
+robust than necessary, and the throughput deficit (§7.3's −37.40% mean)
+is fully consistent with spectral efficiency left on the table at a
+near-perfect success rate — not with an increased failure rate. This
+matches the data cleanly enough that no other explanation is needed for
+RLLA specifically. (Why the ε-greedy running-average estimator converges
+this conservatively is a separate question, already flagged in
+`results/README.md` as unresolved — not re-investigated here; this
+section only establishes that the deficit is BLER-driven-conservatism,
+not an unreliability problem.)
+
+**LTSLA: two different regimes, matching the sign of its throughput gain
+in §7.3 exactly.**
+
+- **3 km/h (both CDL types, favorable configs, +6.68%/+10.06% gain in
+  §7.3): mechanism (c), on-target BLER.** LTSLA's realized BLER (0.0901–
+  0.1020, i.e. 0.90×–1.02× of target) is statistically indistinguishable
+  from OLLA's own (0.0985 at both). LTSLA achieves a real throughput
+  *gain* here at essentially the *same* reliability level as OLLA — this
+  is a genuine spectral-efficiency win (better MCS choice at matched
+  BLER), not a reliability trade-off in either direction.
+- **30/120 km/h (all 4 configs, unfavorable, −2.51% to −10.98% gain in
+  §7.3): mechanism (a), BLER far past target.** LTSLA's realized BLER is
+  1.57×–2.07× of the 10% target (15.66%–20.73% absolute) at every one of
+  these 4 configs, consistently across all 5 seeds (std ≤0.0086). This
+  directly explains the throughput loss: MCS selection is too aggressive
+  for the actual (faster-fading) channel, producing a NACK rate well
+  above design target, and each NACK contributes zero throughput
+  (`_tp_increment`'s `is_ack` gate). The severity **increases monotonically
+  with speed** (30 km/h: 1.57×–1.88×; 120 km/h: 1.74×–2.07×) — consistent
+  with the Doppler-adaptive forgetting factor (`rl_core.py`
+  `_forgetting_factor`, already documented in §2) being insufficient to
+  keep the posterior tracking the channel as fast fading gets faster,
+  causing the point estimate to run stale/optimistic relative to the true,
+  faster-moving SINR. This is consistent with, and adds a concrete
+  reliability-side mechanism to, the regime-dependent pattern already
+  established in §7.3 — not a new or separate finding about *whether*
+  LTSLA underperforms at high speed, but *why*: an under-regulated BLER,
+  not merely a suboptimal but still-reliable MCS choice.
+
+**Per-arm summary**: RLLA underperforms via excess conservatism (BLER
+under target, mechanism b) at every config; LTSLA underperforms via excess
+aggression (BLER over target, mechanism a) specifically at 30/120 km/h,
+and matches OLLA's reliability while beating its throughput (mechanism c,
+a genuine win) at 3 km/h. No config for either arm shows "BLER on-target
+but throughput loss from something else" as the dominant story — mechanism
+(c) only describes LTSLA's *favorable* configs, where it is not a
+"loss" story at all.
+
+### 8.5 Scope of what this resolves — explicitly partial
+
+This diagnostic run resolves the BLER-vs-target check **for P6's own
+6-config × 3-arm × 5-seed grid only** — the same grid `81c76bb`'s
+headline campaign covers, via a **separate, parallel dataset**
+(`P6_bler_diagnostic_seed*_30ktti.csv`), not a retroactive column added to
+the `81c76bb` CSVs themselves (which still have no `mean_bler` column).
+It does **not** resolve the equivalent gap for:
+- Any other project's committed campaign data (P1–P5, P4 Investigations
+  2/3) — none of those runners were touched, and none of their CSVs have a
+  BLER-vs-target verification performed as part of this series.
+- Any future P6 run using a different grid, seed set, or N_TTIS than the
+  one re-used here.
+
+### 8.6 Provenance for this section
+
+| Artifact | Location |
+|---|---|
+| Diagnostic CSVs (5, committed) | `results/P6_bler_diagnostic_seed{42,123,7,99,2024}_30ktti.csv` |
+| Schema change | `projects/p6_rl_link_adapt/runner.py` (`_run_olla`, `_run_rl`, `P6RLRunner._row`/`FIELDNAMES`/`run`) |
+| Consumer updates for the new return shape | `examples/run_p6_rl.py` (`run_demo`), `tests/test_projects.py` (`test_controller_reproducible_same_seed`) |
+| Test suite result after the change | 235 passed, 0 failed (`pytest tests/`) |
+| HEAD at start of this section | `81c76bb` (this document's own §7 commit) |
+| This section | Drafted 2026-07-18, same session as the diagnostic run |

examples/run_p6_rl.py

@@ -47,12 +47,12 @@ def run_demo(seed: int, n_ues: int, speed: float, cdl: str,
              n_ttis: int, n_rb: int) -> None:
     print(f"P6 demo  |  n_ues={n_ues}  speed={speed}km/h  CDL-{cdl}  "
           f"ttis={n_ttis}")
-    olla = _run_olla(seed, n_ues, speed, n_ttis, n_rb, cdl)
-    rlla = _run_rl("epsilon_greedy", seed, n_ues, speed, n_ttis, n_rb, cdl)
-    lts = _run_rl("thompson", seed, n_ues, speed, n_ttis, n_rb, cdl)
-    print(f"  OLLA  : {olla:.3f} Mbps")
-    print(f"  RLLA  : {rlla:.3f} Mbps ({(rlla-olla)/olla*100:+.1f}%)")
-    print(f"  LTSLA : {lts:.3f} Mbps ({(lts-olla)/olla*100:+.1f}%)")
+    olla, olla_bler = _run_olla(seed, n_ues, speed, n_ttis, n_rb, cdl)
+    rlla, rlla_bler = _run_rl("epsilon_greedy", seed, n_ues, speed, n_ttis, n_rb, cdl)
+    lts, lts_bler = _run_rl("thompson", seed, n_ues, speed, n_ttis, n_rb, cdl)
+    print(f"  OLLA  : {olla:.3f} Mbps  (BLER={olla_bler:.4f})")
+    print(f"  RLLA  : {rlla:.3f} Mbps ({(rlla-olla)/olla*100:+.1f}%)  (BLER={rlla_bler:.4f})")
+    print(f"  LTSLA : {lts:.3f} Mbps ({(lts-olla)/olla*100:+.1f}%)  (BLER={lts_bler:.4f})")
 
 
 def main() -> None: