BPSK hard path: cancel_crossfade_isi loses ~24% of frames on moderate_f1 at 12-16 dB — validated on AWGN only (#821)

[dc0sk]

cancel_crossfade_isi on BPSK's HARD path — the shipped receive path — costs decode rate on moderate_f1 once the delay spread reaches ~1 ms. It was validated on AWGN only.

plugins/bpsk/src/demodulate.rs:114 applies the cancellation on the hard differential path. #821's evidence for it is a single fixed-seed AWGN BER at σ = 0.9 (plugins/bpsk/src/lib.rs:286), generalised to a rung whose entire purpose is the fade.

Measured

Ablation on shipped code, comparing the two paths that already differ by exactly this transform — soft (no cancellation) vs hard (cancellation) — through combine_and_decode_llrs, 64 independent fade realisations per cell, BPSK250 + Rs. Frames decoded of 64:

channel	8 dB	12 dB	16 dB
Doppler only (1 Hz, 0 ms)	45 / 60	64 / 64	64 / 64
multipath only (0 Hz, 1 ms)	54 / 54	57 / 56	60 / 57
both (moderate_f1)	28 / 26	50 / 38	54 / 45

(soft / hard — so the right-hand number is what ships.)

Delay-spread sweep at 1 Hz Doppler, hard minus soft: 0 ms +15, 0.25 ms +6, 0.5 ms ≈0, 1 ms −12, 2 ms −6 (both nearly dead at 2 ms). The sign flips near 0.5 ms. On pure Doppler the cancellation is a clear win; combined with ≥1 ms of delay spread it is a clear loss, and moderate_f1 is the combined case.

These fade measurements were made during adversarial review of a related question; I measured the AWGN half (below) and reproduced its numbers independently. The mechanism is not established.

Leading hypothesis, untested

1 ms is 8 samples, a quarter symbol at BPSK250. Under Doppler the dominant ray alternates mid-frame, so preamble-locked timing sits a quarter symbol off for stretches; the effective β is then no longer 1/3, and fixed-β cancellation injects error instead of removing it. That is the #695 shape — "cancel where the ISI structure differs and you inject the next symbol as error" — which is already a known sharp edge in this repo for the QPSK/8PSK crossfade.

Why no gate sees it

hpx_hf_rungs_survive_fade uses MIN_DECODE = 0.25 at floor+4 dB; the hard path reads 0.4–0.6 there, comfortably above the bar while losing a quarter of its frames to a transform that is supposed to help.

Scope — do not generalise past BPSK250

BPSK63 at 8–16 dB is saturated in both arms (31–32 of 32), so its operating point was never reached, and 1 ms is 1/16 of a symbol there rather than 1/4. The slower rungs need their own measurement at floor…floor+4.

Suggested next measurement, before any fix

1. Timing ablation to test the hypothesis: a static two-ray channel plus a forced quarter-symbol timing offset, or log the timing-lock error against frame position on moderate_f1. If the harm tracks the timing error, the fix is timing, not the cancellation.
2. BPSK31/63/100 at floor…floor+4 on moderate_f1, soft vs hard, to find where the sign flip lands on the slower rungs.

Related

#1361 is the soft-path half of the same transform; the soft/hard split question is downstream of this one, because if the cancellation is wrong on the fade for the hard path, "make the soft path match the hard path" is the wrong target. The AWGN A/B that led here is recorded there.

Caveats on the fade numbers: one payload, one Watterson implementation, release profile (the gate runs debug), 64 paired realisations per cell, and it was not checked whether delay_spread_ms maps to an integer-sample delay — which matters directly to the timing hypothesis.

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6

[dc0sk]

Mechanism found, and it is not what this issue's "leading hypothesis" said. The timing story is dead; so is my own first explanation.

What the trigger is

cancel_crossfade_isi is the backward substitution a_k = r_k − β·a_{k+1}, correct when the current symbol dominates its slot (taps 1 : β). When the channel response at the carrier collapses while the band edges survive — a frequency-selective carrier dip, |H(fc)| ≲ 0.35 of a ray in the two-ray case — the composite symbol response loses its DC term, so every no-flip pair yields r_k ≈ 0, a decision tie, while flips still yield large r.

The recursion then fills each tied slot with −β·a'_{k+1}, so consecutive fills alternate in sign, and a differential detector reads alternation as a flip. Every no-flip bit inside the dip decodes as 1.

That predicts BER = ½·1 + ¼·⅔ + ¼·0 = 0.667, which is the 0.64 "worse than random" measured throughout — a deterministic tie-break, not lost margin.

Three things that establish it, rather than fit it

1. β is a step function, not a lever. Same received I/Q at the null, β swept: 0 → 0.187, 0.05 → 0.662, 0.1…0.5 → 0.664 flat. Amplification would scale with β; a step at β→0⁺ means the uncancelled decisions are sitting on an exact tie and any perturbation decides them.

2. The errors are bit-value-conditional, which a resonance cannot produce:

pattern	hard err	soft err
(·, 0, ·), all four	1.000	0.44–0.50
(·, 1, 0)	0.67	0.24–0.32
(·, 1, 1)	0.000	0.000

3. The composite taps show the collapse directly. Clean: (next, cur, prev) = (+0.320, +1.040, 0), the β=1/3 geometry. At the d=8 null: (+0.226, −0.182, −0.044) — sum exactly 0, the signature of a differentiator. Onset is derivable too: harm begins exactly where |g_cur| < |g_next| (ratio 0.60 → BER 0.000; 0.65 → 0.12; 0.70 → 0.405), matching the empirical "≥ 0.7".

Corrections to what I posted earlier

• My mechanism ("the recursion amplifies the residual") is refuted. It is a tie-break. Amplification is excluded by the β step.
• "8 samples is the delay whose comb lands on 1500 Hz" is wrong as a general claim. With the second ray phase-rotated so the carrier is nulled at every delay (2 … 32 samples), the hard path reads 0.646–0.649 at all of them. My static 2 ms cell never tested the claim: two positive real rays at 16 samples give 1 + e^{−j6π} = 2, a carrier peak. Under Watterson the taps are complex Gaussian, so a carrier null is a random event at any delay; the delay only sets the selectivity across the ±250 Hz band, which decides whether a dip is an erasure for both paths (0.5 ms — the band fades with the carrier, no differential) or a tie-break for the cancelled one (1 ms).
• "2 ms does not hurt" is a floor effect, not immunity: both paths are near-dead there, and the sign is still soft ≥ hard.
• My "within 60 Hz" window was never actually exercised. Every confirmed cell is an exact null, (2k+1)·fs/2d = fc. The two approximate in-window cells (d=13 @1500, d=14 @2000) were not in my tested set. A model puts d=14 @1500 at hard 0.145 / soft 0.000 — untested on the real chain, and worth checking.

Frame-level support for the moderate_f1 numbers

The rare-event objection I raised was right as stated — dips deep enough for the hard path to fall below the soft path's coin flip are ~0.5 % of a frame. What carries the 24 % is not those alone. A model of the shipped chain with β on/off as the only variable, Rayleigh two-tap, 0.5 Hz Doppler, preamble-locked timing, RS(t=16) decodability, 24 frames:

delay	SNR	hard	soft	soft-only / hard-only
1 ms	12 dB	16/24	19/24	3 / 0
1 ms	16 dB	16/24	22/24	6 / 0
0.5 ms	16 dB	23	23	0 / 0
2 ms	16 dB	3	7	4 / 0

Zero hard-only decodes in 144 frames. Not established: the per-dip accounting on the real chain.

Consequences for the fix

• β estimation is refuted by the mechanism. A tie has no β that rescues it — every β > 0 gives the same sign, and β_eff = g_next/g_cur changes sign at the null.
• A dominant-tap gate (disable the recursion where |g_cur| < |g_next|) is the targeted candidate, and it has a known ceiling: the sign-sliced soft arm's frame count, which we already measure. The tied bits stay a coin flip either way; beating that needs erasures into RS, an equalizer, or the soft path.
• One question to settle before trusting the 50/38 in this issue's opening: were both arms decoded by the same hard RS? If the LLR arm was decoded softly, that A/B has a second variable and the model above is the cleaner frame-level evidence.
• Tangent, filed separately if it holds up: estimate_snr_db shares symbol_stream, so it measures on cancelled symbols, and in a dip its reconstructed decisions are systematically wrong.

Next measurement, falsifiable

On the real chain, moderate_f1, fixed seed, 1 ms, no source change: recover |H(fc,t)| without private access by pushing a pure cos(2πfc t) of frame length through a second WattersonChannel built from the same seed with noise off, and take its analytic magnitude at symbol centres. Then tabulate P(err | true bit, dip) for both paths.

What would falsify the tie-break: in-dip hard errors not concentrated on bit = 0. The mechanism predicts ≈1.0 on zeros, ≈⅓ on ones, soft ≈0.5 on both, and hard ≤ soft outside dips. An amplification story predicts no bit-value asymmetry at all.

Attribution: the fc/delay sweeps and the β-step, tap and bit-pattern measurements above come from the symbol-domain model built during adversarial review; I measured the original fc-moves-the-delay confirmation on the real chain and reproduced its cells.

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6

[dc0sk]

Qualification to the comment above — and a correction to a correction. I ran the falsification test, read it as a refutation, and it was a diluted confirmation.

What was wrong with my test

The dip window was three times too wide. I used |H| < 0.15 of the two-ray peak, which is < 0.30 of a ray — the onset of harm per the mechanism's own |g_cur| < |g_next| boundary, not the strip where the deterministic fill dominates. Averaged over a window that wide, the signature washes out. Re-binned by depth (drift 6.5→9.5, ratio 1, lock 0):

|H| bin (peak-normalised)	n	hard b0	hard b1	soft b0	soft b1
[0.00, 0.02)	48	0.739	0.520	0.565	0.520
[0.02, 0.05)	70	0.487	0.516	0.385	0.516
[0.10, 0.15)	118	0.383	0.138	0.317	0.414

and the deep-bin bit-0 figure moves 0.74 → 0.96 → 1.00 as the timing offset goes 0 → 4 → 8. My headline "0.514 vs 0.409, no asymmetry" is the 2σ residue of that after dilution; the soft path shows none (0.447 / 0.477).

Two further defects invalidate the regime sweep's verdicts.

1. The timing lock moved between cells and I never logged it. Static τ=8 ratio 0.7 locks at offset 31; drift 7.9→8.1 ratio 0.7 locks at 0. That is the entire static-vs-drift "reversal" I reported — the lock, not the drift. An equal-amplitude ray a quarter-symbol away makes the preamble-energy argmax a near-tie, and it landed on 0, 1, 8, 10, 13, 31 across my cells. Until each cell carries its lock offset, "helps/HURTS" is not attributable to the axis I swept.
2. I swept half the ratio axis. Ratio ≤ 1 keeps the undelayed ray dominant — the benign side. Rayleigh has the delayed tap dominant half the time. On that side the transient harm is large at shallow depth: τ 7.5→8.5 with ratio 1/0.9 gives hard 0.245 vs soft 0.000 (172 bad bytes vs 0). So "at ratios ≤ 0.9 the cancellation is usually beneficial in transient dips" is true of the half I measured and false of its mirror. Withdrawn.

Where the harm actually lives — the real correction

The deterministic ⅔ is the deep-null limit of a graded harm, not its onset. On Rayleigh two-tap (1 ms, 1 Hz, ~16 dB, 24 frames), errors binned by |H(fc,t)| and by which tap dominates:

|H| bin	delayed dominant	nbits	hard	soft	excess	hard err|b0	err|b1
[0.00, 0.03)	yes	20	0.700	0.100	+12	0.900	0.500
[0.03, 0.10)	yes	200	0.335	0.150	+37	0.515	0.165
[0.10, 0.20)	yes	674	0.156	0.025	+88	0.230	0.077
[0.20, 0.30)	yes	1173	0.052	0.011	+48	0.084	0.023
[0.10, 0.30)	no	1667	0.19	0.23	−63
[0.50, ∞)	either	38132	0.02	0.05	−917

The bit-0 signature is in every dip bin, and the excess sits at shallow depths where the delayed tap dominates — not in near-exact nulls, which are ~2 bits per frame. "Dwell time" is not the variable; which tap dominates is, and my two-ray never varied it.

Severity is unchanged, and my whole-frame BER metric pointed the wrong way

Census at 1 ms / 1 Hz: ~205 bits per frame below |H| = 0.3 — about 26 bytes, which parks a BPSK250 frame on the RS t=16 cliff by construction. Over 24 frames the hard path made 895 fewer bit errors than soft and decoded fewer frames. It trades a burst inside the dip for scattered errors in the clean region that RS corrects anyway, which is exactly why my "HURTS barely" whole-frame BER readings inverted the conclusion. Count bytes, not bits.

The condition is not rare. It is the default fade of the profile this rung exists for.

Also withdrawn

The static noiseless soft figure of 0.054 I quoted is lock-dependent — a model of the chain reads 0.16–0.53 across offsets and never 0.054 — and it contradicts the soft column in my own comment above. Quote the static gap as hard ≈0.67 vs soft ≈0.5.

One more thing to check in my own apparatus: two cells read exactly 0.50000 on 2040 bits, which is not what iid data does twice. My payload is i·37 & 0xff, and a structured payload changes the run-length distribution the ⅔ derivation assumes.

What this changes for the fix

The |g_cur| < |g_next| predicate stands, but it fires at 5–10 % of bits, not on rare nulls, and its onset depends on where the lock sits relative to the dominant tap. Its ceiling — the soft arm — is high in exactly those dips (0.011–0.025 against hard's 0.05–0.16).

Next real-chain measurement: repeat the drift probe with ratio 1/0.9 and 1/0.7 so the delayed ray dominates, log find_timing_offset's result for every cell, and count byte errors rather than BER.

Tangent worth its own note: in 4 of 24 Rayleigh frames the preamble lock chose offset 9–13 and both paths lost the frame; forcing 0 recovered 3 of them for the hard path and 6 for the soft.

Attribution: the re-binning, the Rayleigh census and the lock-offset diagnosis come from a symbol-domain model of the shipped chain built in review, validated by reproducing my real-chain cells to within 0.02. The three probe defects are mine.

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6

[dc0sk]

Maintainer decision (2026-09-16): measure the mechanism before touching the code.

No revert, no gate-bar change, no deferral until the timing ablation this issue proposes has run.

The reasoning is this issue's own: the mechanism is not established. The measured harm is real
(50/38 and 54/45 at 12/16 dB on moderate_f1, soft vs hard) and the sign flips near 0.5 ms of delay
spread — but the leading hypothesis says the cancellation is innocent and the timing lock is the
defect. If that is right, disabling cancel_crossfade_isi on the hard path is a symptom fix that
also throws away its pure-Doppler win (+15 at 0 ms) and the AWGN case #821 added it for, while
leaving the real defect in place. This repo has paid for the opposite ordering repeatedly — build the
fix the explanation implies, then find the explanation was never the mechanism (#685, #688, #689).

So, in order:

1. Timing ablation. Static two-ray channel plus a forced quarter-symbol timing offset, or log the
   timing-lock error against frame position on moderate_f1. If the harm tracks the timing error,
   the fix is timing, not the cancellation.
2. BPSK31/63/100 at floor…floor+4 on moderate_f1, soft vs hard, to find where the sign flip
   lands on the slower rungs. Do not carry BPSK250's number to them: BPSK63 is saturated in both arms
   at 8–16 dB (31–32 of 32), so its operating point was never reached, and 1 ms is 1/16 of a symbol
   there rather than 1/4.

Resolve first, because it can invalidate cell 1: the issue's own caveat that it was never checked
whether delay_spread_ms maps to an integer-sample delay. That bears directly on the timing
hypothesis — a fractional-sample delay and a quarter-symbol timing error are not the same experiment.
Check it before running the ablation, not after.

And the gate cannot adjudicate any of this — hpx_hf_rungs_survive_fade uses MIN_DECODE = 0.25
where the hard path reads 0.4–0.6, so it is comfortably green while losing a quarter of its frames
(#1364). Tightening that bar is part of whatever repair lands, not a step before the measurement:
a bar tightened before the mechanism is known is a constant fitted to the two cells we have.

Everything measured goes to adversarial review with its apparatus before it becomes the premise of a
fix. #1361 (the soft-path half) stays downstream of this, as this issue already states.

[dc0sk]

Precondition resolved before the ablation: delay_spread_ms DOES map to an integer sample delay
at every value this issue swept — so cell 1 is not invalidated. Code read at a821dc14, no
execution.

WattersonChannel computes the delay as a truncating integer cast, at two sites:

crates/openpulse-channel/src/watterson.rs:127-128   (apply_complex)
crates/openpulse-channel/src/watterson.rs:181-182   (apply)
    let delay_samples =
        (self.config.delay_spread_ms / 1000.0 * self.config.sample_rate as f32) as usize;

There is no fractional-delay interpolation anywhere in that file (my filter for
interp|lerp|fractional|frac_delay|farrow found nothing in watterson.rs; as a control the same
filter matches openpulse-dsp/src/farrow.rs, freq_acquire.rs and notch.rs, so it does work).

At the default sample_rate = 8000 (openpulse-channel/src/lib.rs:220 and siblings; also
openpulse-core/src/audio.rs:107), every swept value lands exactly:

delay_spread_ms	exact samples	as usize	exact?	BPSK250 symbol fraction (32 sps)
0.0	0.000	0	yes	0
0.25	2.000	2	yes	1/16
0.5	4.000	4	yes	1/8
1.0	8.000	8	yes	1/4
2.0	16.000	16	yes	1/2

So the issue's arithmetic is right: 1 ms is exactly 8 samples, exactly a quarter symbol at
BPSK250, and a fractional-sample delay is not a confound in any cell already measured.

Two things this changes for the ablation, though.

1. The truncation is a live trap for a FINER sweep, which is exactly what this issue proposes.
   A non-round value silently truncates rather than rounding: 0.3 ms → 2.4 → 2 samples, i.e. an
   actual 0.25 ms reported as 0.3 ms, a 17 % error with nothing printed. Any refinement of the
   delay-spread sweep must either stay on the 0.125 ms grid (1 sample at 8 kHz) or assert the
   realised delay_samples rather than the requested milliseconds. This is the
   reproduction-harness-by-reference rule: the parameter the channel USES is
   delay_samples, and that is what the write-up must quote.
2. The sign flip does not sit where the hypothesis puts it. The hypothesis is that
   preamble-locked timing sits "a quarter symbol off"; a quarter symbol is 1.0 ms, which is where
   the harm is already maximal (−12). The measured flip is near 0.5 ms = 4 samples = an eighth
   of a symbol, and 2.0 ms is a full half symbol where both arms are nearly dead. So the
   mechanism, if it is timing, turns over at 1/8 symbol rather than 1/4 — the ablation should sweep
   the forced timing offset across 0…1/2 symbol in 1-sample steps and find where ITS sign flips,
   rather than testing 1/4 symbol alone and reading a single number as confirmation.

Neither point touches the measured cells; both change how the next measurement is parameterised.

[dc0sk]

Correcting my own decision comment above. It restated this issue's BODY, and two comments from
2026-09-13 had already moved past it — including one that declares the hypothesis I told us to test
dead. Caught in adversarial review of the ablation I was about to build. Nothing was built.

What I got wrong

My 2026-09-16 comment framed the work as "test the timing hypothesis: preamble-locked timing sits a
quarter symbol off, so the effective β is no longer 1/3". That is the body's leading hypothesis,
untested, and the 12:50 comment on 2026-09-13 opens by retiring it: "The timing story is dead; so
is my own first explanation." I then designed a whole ablation around the dead hypothesis, and my
follow-up about "the sign flip is at 1/8 symbol, not 1/4" was refining a question that had already
been answered.

This is the second occurrence of the same archetype — #1062's review found me reviewing an issue
body while ten comments had moved past it. The cost there and here is identical: a correct-looking
plan aimed at a settled question.

What the thread actually establishes

The mechanism is a carrier-dip TIE-BREAK, not lost margin. When the composite response at the
carrier collapses (|H(fc)| ≲ 0.35 of a ray) the symbol response loses its DC term, so every
no-flip pair yields r_k ≈ 0 — an exact decision tie — while flips still yield large r. The
backward substitution fills each tied slot with −β·a'_{k+1}, so consecutive fills alternate in
sign, and a differential detector reads alternation as flips. Predicted BER
½·1 + ¼·⅔ = 0.667, against the 0.64 measured.

Three things establish it rather than fit it: β is a step, not a lever (0 → 0.187, 0.05 → 0.662,
then flat to 0.5 — amplification would scale with β); the errors are bit-value-conditional
(hard err | bit 0 = 1.000, | bit 1 = 0.000), which no resonance produces; and the composite taps
show the collapse directly — clean (next, cur, prev) = (+0.320, +1.040, 0), at the null
(+0.226, −0.182, −0.044), summing to zero, the signature of a differentiator.

And the harm lives where the DELAYED tap dominates — the half of the ratio axis no two-ray cell
had swept (excess +88 at |H| ∈ [0.10, 0.20) delayed-dominant, versus −63 in the same bin
direct-dominant). Not in near-exact nulls, which are ~2 bits per frame. "Which tap dominates" is the
variable; dwell time is not.

Why the timing story cannot be right, structurally (from review, and it is the cleanest
refutation): the crossfade path has no timing tracking at all. One lock per frame via
find_timing_offset_with_expected, then demodulate_iq slices at a fixed offset + sym_idx·n. The
channel moves under a fixed lock; timing cannot "sit off for stretches" because nothing re-locks.
The real variable is the lock's position relative to the dominant tap, which has a sign — and my
proposed sweep covered only the benign (late) half.

The design consequences, so this is not just a retraction

• A1 as I designed it is withdrawn. A single-ray forced-δ sweep measures fixed-β robustness to
  lock error, which a closed-form tap model already answers; it survives only as a negative control.
• "Doppler = 0" via WattersonConfig does not give a static channel. doppler_envelope floors
  sigma_bins at 0.5, so a nominally-zero-Doppler frame still carries ~19 % rms wobble, and each
  seed draws an independent complex ray ratio. The issue's own "multipath only (0 ms Doppler)" row
  was therefore quasi-static at a random uncontrolled ratio. A controlled static two-ray with a
  complex ratio is needed instead.
• 30 dB and frame counts is an instrument that cannot fail here. Count bytes, not bits: the
  hard path made 895 fewer bit errors than soft across 24 frames and decoded fewer frames,
  because it trades a burst inside the dip for scattered errors RS corrects anyway. Whole-frame BER
  inverted the conclusion once already.
• The Q4 worry is answered by the code, and in the reassuring direction.
  combine_and_decode_llrs hard-decides each attempt and RS-decodes with the same
  rs_decode_free_strengthened and stage_decode_frame the hard arm uses, and sign-slicing the
  differential LLR is identical to differential_decode's dot < 0. So soft-vs-hard through the
  engine with Rs IS a pure cancellation toggle, with zero private access — provided a soft FEC
  mode is never used for the A/B.
• A structural twin I had not listed: QPSK250-D, hpx_hf SL6. Same shape —
  find_timing_offset → demodulate_symbols → cancel_crossfade_isi → differential_decode, no
  equalizer — and its soft path refuses -D, so it has no soft arm at all and only an in-crate
  toggle can measure it. Its fade gate was measured with cancellation ON only.

What should actually be measured next

The thread already names it, and it is falsifiable: on the real chain, moderate_f1, 1 ms, fixed
seed, recover |H(fc,t)| by pushing a pure cos(2πfc t) through a second WattersonChannel built
from the same seed with noise off, then tabulate P(err | true bit, dip) for both paths — with the
delayed ray dominant (ratio 1/0.9, 1/0.7), the lock offset logged for every cell, and byte errors
counted. The mechanism predicts ≈1.0 on zeros and ≈⅓ on ones for the hard path, ≈0.5 on both for
soft. What falsifies it: in-dip hard errors not concentrated on bit = 0.

The candidate fix the mechanism implies is a dominant-tap gate — disable the recursion where
|g_cur| < |g_next| — with a known ceiling (the sign-sliced soft arm's frame count) and a known
firing rate of 5–10 % of bits, not rare nulls. β estimation is refuted outright: a tie has no β that
rescues it.

The maintainer's decision — measure before touching the code — stands unchanged. What changes is
which measurement, and that my framing of it was aimed at a question this thread had closed three
days earlier.

[dc0sk]

MEASURED on the real chain, and the tie-break's falsifier did not occur. Reviewed before posting;
the review corrected my reading of my own numbers and three apparatus defects, all listed below.

The claim

On the shipped BPSK250 crossfade chain (composed arm byte-identical to bpsk_demodulate), Watterson
moderate_f1 at 16 dB, 96 seeds, 200 B payload, no FEC, errors binned by absolute |H(fc,t)|
recovered from the same seed:

|H|	soft b0	soft b1	HARD b0	HARD b1	n
[0.00,0.02)	0.556	0.317	0.694	0.293	77
[0.02,0.05)	0.377	0.365	0.745	0.385	412
[0.05,0.10)	0.263	0.247	0.539	0.296	1421
[0.10,0.20)	0.130	0.144	0.250	0.152	4729
[0.20,0.35)	0.060	0.060	0.075	0.040	10958
[0.35,inf)	0.016	0.017	0.011	0.006	139701

With cancel_crossfade_isi ON, in-dip errors concentrate on true bit 0 — b0/b1 ratios 1.94, 1.82,
1.64 across the three bins with useful n. The same bits through the same chain with cancellation
OFF are symmetric — 1.03, 1.06, 0.90. The falsifier set by this thread ("in-dip hard errors NOT
concentrated on bit 0") did not occur.

err|b1 ≈ 0.29–0.39 in those bins matches the tie-break's predicted 1/3 — a flip decodes
correctly only when the NEXT bit is also a flip, so err|b1 = 1/2 · 2/3 = 1/3. err|b0 reaches
0.745 against a predicted 1.0.

What I got wrong, and the review caught

I read err|b1 ≈ 0.35 as a DEVIATION from the prediction. It is the prediction hit. The probe's
own docstring said "HARD b1 -> ~0.0", which is simply wrong — this thread's comment of 2026-09-13
predicts "≈1.0 on zeros, ≈⅓ on ones". Corrected in the code and above.

The shortfall of err|b0 from 1.0 is NOT attributable to the mechanism at this SNR. Symbol-domain
noise here is σ_sym ≈ 0.039 against a tie-break fill of β·g_next ≈ 0.053 — only 1.4×. So in the two
deepest bins noise breaks the tie about as often as the recursion does, and "graded rather than
deterministic" is confounded with "graded by noise". An SNR axis (16/24/32 dB, same seeds) is
required before any claim about a graded onset. The thread's own model ran its exact-null cells
noiselessly, which is why it saw the clean 2/3.

The deepest bin is uninformative and I am not citing it for either arm. n = 77 (n = 52 in the
first run); Fisher exact on that run gave p = 0.094 (soft) and 0.050 (hard), and those are optimistic
because the samples come from ~30 null crossings whose adjacent symbols share the channel state. At
that depth both arms are noise coin-flips.

I over-claimed the reproduction. The probe counts bits, and has no byte or frame metric. It
reproduces the thread's "895 fewer bit errors" (here: 537 fewer — hard 3605 vs soft 4142, while being
worse in every dip bin) but not the "and decoded fewer frames" half, which I had claimed. Counting
bytes remains this thread's own outstanding instruction.

Apparatus, and three defects fixed before posting

Two assertions run in the DEFAULT test run, not under --ignored:

• the_composed_arm_matches_the_shipped_demodulator — byte identity against bpsk_demodulate, so
  the probe measures the product's chain and not its own.
• the_same_seed_reproduces_the_same_fading_realisation — and, after review, the invariance the
  recovery ACTUALLY relies on: that the fading does not depend on snr_db. The first version
  asserted same-config determinism and called that the premise; the recovery reads the envelope at
  snr 200 and applies it to a frame faded at 16, so envelope-vs-noise independence is the thing that
  matters. Now asserted against the expected additive-noise rms.
• Truth is now tied to the generator, not only to arm agreement. Both arms agreeing on a clean
  channel is a self-consistent reference; the clean decode is now asserted to reproduce the
  transmitted payload, and the clean lock asserted to be 0.
• Absolute |H|, not per-seed median. doppler_envelope normalises to unit mean-square, so
  absolute values are already comparable across seeds — and a median was a THIRD normalisation in
  this thread ("of a ray", "peak", "median") with nothing converting between them.

And a dilution error worth recording, because this thread already made it once. My first run used
24 seeds with edges at 0.15/0.30/0.50 of the median; its deepest bin came back empty and the
signature averaged away. I only saw it because the table prints bin counts.

What is NOT established

• The deterministic deep-null limit (needs high SNR, see above).
• Which tap dominates — moderate_f1 draws complex rays per seed, so both cases are sampled and
  neither is CONTROLLED. Review notes this is available without private access via apply_complex at
  delay_spread_ms 0 and 1.0 on the same seed, which splits env0/env1. That is the next
  measurement.
• Anything about the fix. The dominant-tap gate remains the candidate, with its known ceiling (the
  sign-sliced soft arm) and ~5–10 % firing rate.

Scope of the mechanism, stated more honestly than the body does

The same recursion algebra turns any zero-mean residual in a collapsed slot into a negative
differential bias — E[ñ_k ñ_{k−1}] = −βσ²/(1−β²) — of which the noiseless tie-break is the limit.
That is a generalisation of the thread's mechanism, not a rival to it, and it is what a 16 dB run
sees.

Probe: plugins/bpsk/src/demodulate.rs, module carrier_dip_tiebreak. The measurement is
#[ignore]d — it prints a table and asserts no threshold.

[dc0sk]

All three outstanding measurements are now in hand, including the one I called impossible. The headline is an 8-frame gap that does not close at infinite SNR — and two of my four first readings were wrong.

Reviewed before posting; the review supplied the tap split, the alignment fix, the by-distance
breakdown and the noise-free row, and corrected the two readings. Every number below was then
re-run in-tree and reproduces.

Headline: the cost is SNR-independent, and present with no noise at all

96 seeds, BPSK250, 200 B, no FEC, moderate_f1. "Lost" = more than RS(255,223)'s t=16 bad payload
bytes, on the payload-aligned slice:

SNR	soft lost	HARD lost	gap
16 dB	13	21	8
24 dB	11	19	8
32 dB	11	19	8
noise-free	11	19	8

The gap is 8 frames of 96 at every SNR, including with the noise removed entirely. Any
SNR-conditioned mitigation is therefore ruled out. At 24 dB and above soft's lost seeds are a strict
subset of hard's (hard-only: 0, 9, 15, 21, 47, 50, 68, 76); at 16 dB there is one soft-only loss
(seed 50), so it is not a subset at every SNR.

The bit/byte inversion this thread warned about is confirmed at every SNR: hard makes fewer wrong
bits (3153 vs 3683 noise-free) while producing more bad bytes (1223 vs 1078) and losing more
frames. It trades a burst inside the dip for scattered errors RS corrects anyway.

The third measurement: which tap dominates — and this is where the frames go

I claimed the env0/env1 split was not recoverable without private access. That was wrong.
ray_envelopes draws env0 then env1 from the seeded RNG before any noise sample and reads
neither delay_spread_ms nor snr_db, so the same seed gives identical rays under any delay.
apply_complex at delay 0 with a DC probe gives (e0+e1)/√2; at 1 ms with a complex 1500 Hz tone
(1.5 cycles → e^{-j3π} = −1) it gives (e0−e1)/√2. Sum and difference give both rays, labelled.
Cross-checked against carrier_envelope: 0 of 96 seeds deviate by more than 0.02; mean |e0|²
0.982, |e1|² 1.001; delayed-dominant fraction 0.508.

Noise-free, |H| ∈ [0.05, 0.20), err b0/b1 (n ≈ 1510–1588 per cell):

dominant tap	soft	HARD
direct	0.295 / 0.303	0.333 / 0.242 — on par, better on b1
delayed	0.008 / 0.011	0.236 / 0.114

That is the finding. In mid-depth dips where the delayed ray dominates, the uncancelled arm is
essentially clean (0.008) and the cancelled arm is not (0.236) — a factor of ~30. In the deep bin
(<0.05) hard is bad under both orderings, but that bin holds only ~2.6 bits per frame, so the
frames are not lost there. This replicates the thread's Rayleigh model table on the real chain.

Resolving "deterministic vs graded" — and my first reading was wrong

I read the SNR axis as refuting the deterministic deep-null limit, because pooled err|b0 plateaus
at ~0.67 instead of rising to 1.0. That was a bin artefact and the plateau is the mechanism.

"Deep" (<0.05) is effectively one bin: n per bit is 9 / 27 / 212 across [0,0.01) / [0.01,0.02) /
[0.02,0.05), so 85 % of the pooled figure is the shallowest slice. In that slice the tie is not
exact — a no-flip pair gives r_k = a·|H|² > 0 and decides correctly — while the competing fill
−β·a'_{k+1} decays geometrically with the distance d to the next true flip. So the noiseless
prediction for a finite bin is ≈1 at d=1 and falling beyond. Measured (n = 126 / 67 / 31 / 24):

SNR	d=1	d=2	d=3	d≥4	pooled
16 dB	0.905	0.612	0.581	0.417	0.738
24 dB	0.921	0.463	0.452	0.250	0.673
32 dB	0.929	0.448	0.452	0.167	0.665
noise-free	0.937	0.388	0.484	0.000	0.651

d=1 rises toward 1 as noise is removed; the far slots fall toward 0 as the residual DC term wins.
Pooled by P(d) = 2^-d that is the observed plateau, and the slight fall with SNR is what
residual-signal-deciding-correctly predicts. The "→ 1.0" was always a statement about H ≡ 0, which
is measure zero — not about a bin. Consistent with the tie-break, monotone across four SNRs, on
n = 126; not "shown".

Also worth recording: soft's d=1 is 0.54 at every SNR including noiseless. The uncancelled
+β leak already makes the pre-flip bit a coin flip in a dip; the cancellation converts that coin
flip into a near-certain error and propagates it backward.

Retractions from my earlier reading

• "Exactly 21 lost frames at all three SNRs" — an artefact. My byte grouping started at
  differential bit 0, 31 bits before the payload's byte boundary, so it included preamble bytes.
  Payload-aligned the counts are 21 / 19 / 19 / 19. The robust statement is the gap of 8, not a
  pinned integer.
• "Soft improves while hard is pinned" — wrong. Aligned, both arms drop by 2 from 16→24 dB and
  neither moves from 24 dB to noise-free.
• "The tap split is impossible without private access" — wrong, as above.
• The harness's own printed prediction ("HARD err|b0 rises toward 1.0 as SNR removes the competing
  noise") is the exact-null prediction misapplied to a bin. It is what produced my misreading and is
  being rewritten in terms of d=1.

What this changes for the fix

The dominant-tap gate (disable the recursion where |g_cur| < |g_next|) keeps its standing and
now has real-chain support for its target regime — delayed-dominant, mid-depth, where soft reads
0.008 against hard's 0.236. Three sharpenings:

1. SNR-conditioned mitigation is ruled out by the noise-free row.
2. This thread's "ceiling = the soft arm's frame count" is loose. Hard is on par or better in
   direct-dominant dips and in the clean region, so a per-symbol gate's ceiling is the oracle;
   soft's count is a lower bound on it. The 8-frame gap is what is certainly on the table.
3. The open problem is ESTIMATION, not the predicate. Dominance here is a genie label read from
   the channel's own envelopes. It changes across a frame (1 Hz Doppler against a ~6.5 s frame), and
   it is absolute dominance — not dominance relative to the timing lock, which this thread has
   said is the real variable. A (lock × dominance) breakdown is the next slice and is not done.

Caveats, stated rather than buried

• The byte count covers the 200 payload bytes, not the 255-byte wire frame (4 B prefix + 10 B
  envelope + padding + 32 parity), and RS counts errors across all 255. It is a lower bound on
  losses for both arms, and "seeds with >16 bad payload bytes" is not a decode rate — do not
  equate 19/96 with this issue's opening 50/38.
• No scrambler, and RS is not actually run.
• Deep-bin figures are paired by seed but clustered; nominal SE ≈ 0.03 per bit, effective n smaller.
• Timing-lock confound checked: noisy lock differs from the noise-free lock in 3 / 1 / 0 seeds at
  16 / 24 / 32 dB, and a fixed-lock pass moves every table entry by ≤ 0.01.
• err|b1 in the pooled deep bin drifts 0.37 → 0.44 noise-free on n ≈ 240; no trend should be read
  from it, and the ⅓ prediction is an exact-null number.

Apparatus: the in-crate carrier_dip_tiebreak harness, arms composed from the shipped private
pieces with cancel as the only difference, under its default-run fidelity assertions
(the_composed_arm_matches_the_shipped_demodulator, the_same_seed_reproduces_the_same_fading_realisation).

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6

[dc0sk]

(lock × dominance), the slice named last time. The mechanism in the band where frames are lost is not the tie-break — it is a SIGN-INVERTED β with an intact DC term. And the predicate this thread has been carrying does not fire on the harmful cells.

Reviewed before posting. The review reproduced the table bit-identically, then built an independent
static two-ray model (same crossfade pulse, same w_tail matched filter, same fixed β=1/3
recursion, Rayleigh-drawn static rays, no Doppler) which reproduces all four cells within
±0.03 — so the table is not an artefact of the Watterson realisation, the envelope recovery,
clustering, or Doppler. What the review then corrected was my reading, in four places.

The measurement

Lock FORCED to each ray's own arrival (0 and 8 samples; n=32, so a quarter symbol apart and bit
i still maps to transmitted bit i in both). Noise-free, |H| ∈ [0.05,0.20), 96 seeds, BPSK250,
200 B, no FEC.

lock	dominant	soft b0/b1	HARD b0/b1	n
0	direct	0.272 / 0.274	0.301 / 0.210	3032
0	delayed	0.010 / 0.017	0.209 / 0.117	3125
8	direct	0.450 / 0.456	0.496 / 0.393	3066
8	delayed	0.003 / 0.000	0.348 / 0.124	3109

What the cells actually are — the composite taps, which I should have printed

The matched filter is time-asymmetric, so "early" and "late" are not ± the same thing and the two
aligned cells are not mirror images. Per-ray composite taps (coefficient of a_{k+m} in r_k):

ray geometry	cur	next	prev
aligned to the lock	1.00	0.32	—
late by 8	1.19	0.09	0.04
early by 8	0.61	0.71	—

So in a two-tap channel, "the delayed ray dominates" is identical to "the sub-dominant echo is
a pre-echo", and what the 2×2 isolates is the sign of the effective ISI coefficient
β_eff = g_next/g_cur. Median Re β_eff across the four cells: +0.25 / −0.25 / −0.86 / −0.38
(fraction negative 0.31 / 0.86 / 0.74 / 0.84).

In both delayed-dominant cells the composite DC term is intact (|g_cur| > |g_next|, which is
why the uncancelled arm is ~clean) and β_eff is negative — so the fixed +1/3 canceller ADDS
ISI. That is not a tie-break; a tie-break needs a collapsed DC term. In both direct-dominant cells
the DC term is collapsed (lock 0) or swamped by the forward leak (lock 8), both arms lose 25–45 % of
bits, and the canceller is not what loses them.

Corrections to my own reading

• "Alignment is a near-bystander for the hard/soft difference" — wrong. Alignment moves the
  delayed-dominant penalty from 0.20 to 0.345, which is five times the entire direct-dominant
  penalty. Correct statement: alignment modulates the penalty within the delayed-dominant
  condition; it does not switch it on or off. (Readings 2 and 3 of my draft contradicted each other
  and the review caught it.)
• My collinearity argument was wrong, though forcing the lock was still right. The lock is set
  once at preamble time and dominance at a dip seconds later is nearly independent of it (1 Hz
  Doppler against a 6.6 s frame), so there is no collinearity in principle. The real reason is that
  the found-lock distribution is degenerate: lock 0 in ~96 % of frames when the preamble sits in
  a direct-dominant dip and ~77 % when delayed, scattering to 8–11 only in the ~4 % of frames whose
  preamble lands in a delayed-dominant dip. A found-lock cross-tab has no lock-8 cell at all.
• Consequence I should have drawn: the product lives in the lock-0 row. The lock-8 rows are a
  mechanism probe, not a product weighting. The loss on air is carried by lock-0 / delayed-dominant
  (penalty 0.20); the worst cell (0.345) is rare.
• Instrument defect, mine: the earlier probe printed its lock list through dedup(), which threw
  away exactly the histogram this argument needs. [0,1,2,3,4,5,7,8,12] was a set, not a
  distribution, and I quoted it as if it showed spread.
• Scope: this is a mid-band statement. In [0.20,0.35) the penalties are ≈0 (except lock-8
  delayed at 0.08); in [0.00,0.05) the direct-dominant penalties become large too (0.11, 0.27) —
  that deep bin is the genuine tie-break regime this thread established, and it is a different
  mechanism from the one above.

Which reading of this thread's hypothesis is refuted

The 2026-09-16 sentence — "the lock's position relative to the dominant tap" — admits two readings,
and they come apart here:

• "the LOCK's alignment relative to the dominant tap is the variable" → refuted. The two
  aligned cells give penalties of 0.03 and 0.345.
• "the ECHO's position relative to the dominant tap, benign when late" → confirmed, and is
  the same statement as the pre-echo/sign-inversion account above.

I framed this as contradicting the thread. It refutes one reading and confirms the other; the
09-13 comment's "which tap dominates is the variable" stands.

The fix — MODEL ONLY, and my draft conclusion was wrong

The predicate this thread has carried — |g_cur| < |g_next| — does not fire where the harm is.
In the model it fires in 0–1 % of delayed-dominant mid-band bits (where the penalty lives) and
47–89 % of direct-dominant bits (where it does not). Gating on it leaves the delayed cells at
exactly the hard arm's numbers and slightly worsens the direct ones. So "a dominant-tap gate keyed on
absolute dominance" — which is what I was about to write — is not supported unless "dominant tap"
is silently redefined from composite-tap to ray dominance, and ray dominance is a genie label.

Two arms that do work in the model:

arm	delayed-dom cells (b0/b1)
Re(g_next · conj g_cur) < 0 — sign of the effective ISI	0.012/0.014 and 0.002/0.000, no cost in the direct cells
genie complex-β cancellation (one-tap anti-causal)	0.005/0.007 and 0.000/0.000 where `

So "β estimation is refuted by the mechanism" — recorded on 2026-09-13 — is a deep-null statement
that does not carry to the band where the frames are actually lost. β estimation is back on the
table for mid-band, and there is a reason to think it is reachable: in delayed-dominant mid-band the
uncancelled decisions are essentially error-free, so a decision-directed LS estimate of β_eff
(regress r_k on decided a_k, a_{k+1} over a window) is available precisely where it is needed.
Ray powers never are.

None of this last section is established on the real chain. It is model evidence. Porting
taps() and the gate_thread / gate_sign / beta_eff arms into the Rust harness — they need only
demodulate_iq on an impulse frame plus the existing ray_split genie — is the next measurement,
and nothing about the fix should be decided before it runs.

Attribution: the two-ray model, the composite taps, the β_eff statistics and the three gate arms
come from the review; the 2×2 table and its harness are in mod carrier_dip_tiebreak (#1427).

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6

[dc0sk]

The gate arms, ported to the real chain and measured OFF the fade band as well. This issue's own predicate is retired, "β estimation is refuted" is withdrawn in full, and the one receiver-realisable arm has a measured cost I would not have found without the off-band cells.

Reviewed before posting; the review supplied the least-squares estimator, the two shuffle controls
and the off-band cells, and caught that my own estimator was the instrument's defect. All numbers
below were then re-run here. Two corrections to my previous comment are at the end — one of them
is an attribution error I should not have made.

The instrument was wrong first

My estimate_taps used sliding-window correlation, ⟨r_k·a_{k+m}⟩ over 41 symbols. Its
"cross terms average out" premise fails on a real payload: 1/√41 ≈ 0.16 of relative self-noise.
On a clean frame, no channel, no noise, genie symbols (n=1518):

	correlation (what I used)	least-squares
Re(g_next/g_cur) p05 / p50 / p95	0.043 / 0.285 / 0.532	0.307 / 0.308 / 0.308
sign fires / sign_dd fires	4.3 % / 4.3 %	0.0 % / 0.0 %

So the "genie" arms were genie symbols through a noisy estimator, and my doc comment calling
beta "a CEILING, not an achievable receiver" was false — with that estimator it was a floor.
Everything below uses LS (4×4 normal equations, ridge 1e-3·n because the period-4 preamble is
rank-deficient). thread's fire rates are identical under both, so nothing about thread depended
on it.

|g_cur| < |g_next| — this issue's predicate — is retired

Fires 3.9 % / 4.9 % in the delayed-dominant cells where the penalty lives, 48.1 % / 83.6 %
where it does not. It leaves the delayed cells at the shipped arm's numbers (0.196/0.109 and
0.319/0.108 against hard's 0.209/0.117 and 0.348/0.124) — and it is worse than the shipped arm at
frame level in every cell measured: 21 vs 19 noise-free, 47/29/22 vs 45/26/21 on the fade. Not
merely "does not fire where the harm is": it costs frames.

Off-band, which my earlier draft could not see

Frames lost (>16 bad payload bytes of 200), 96 seeds, found lock, with noise:

cell	soft	hard	thread	sign	beta	sign_dd	beta_dd
moderate_f1 1 ms @ 8 dB	33	45	47	28	24	32	26
@ 12 dB	19	26	29	19	15	20	14
@ 16 dB	13	21	22	15	12	15	14
Doppler-only 0 ms @ 8 dB — the +15 row	18	5	5	5	6	7	16
AWGN −2 dB	56	0	0	0	0	0	54
AWGN −3.3 dB (#821's σ = 0.9)	96	46	46	46	25	83	96
AWGN ≥ 0 dB	0	0	0	0	0	0	0

I was right to doubt my own draft. sign_dd keeps the pure-Doppler win (7 against hard's 5,
soft's 18) and the AWGN win down to −2 dB — but forfeits most of it at −3.3 dB: 83 lost against
hard's 46. That is exactly #821's validation regime, and it is noise-driven misfire, not a
property of the channel: the predicate fires 7.7 % there against the genie's 0.0 %. A real cost,
located 8 dB below SL5's 5 dB floor. Whether that regime is a product regime is a maintainer call;
it is not mine to omit.

"β estimation is refuted by the mechanism" is withdrawn in full

With exact taps, genie complex-β is the best arm in every cell measured — 24/15/12 on the fade,
6 on pure Doppler, and 25 at −3.3 dB AWGN against hard's 46. What the 2026-09-13 note actually
refuted is a deep-null statement; what this refutes is a 41-symbol correlation estimate. The
direction is open.

beta_dd is the best arm on the fade (26/14/14, better than soft) and disqualified off it as
built: 16 lost on pure Doppler against hard's 5, 54 at −2 dB AWGN against hard's 0. The weak link
is the decision-directed symbol reconstruction — one differential error flips the entire downstream
stream, so every 41-window straddling it sees two sign populations. The sign survives that (both
taps scale together); the value of β does not. A DD estimator built on pairwise products
r_k·conj r_{k−1} against decided bits would confine an error to its own row. That is a design, not
a result.

Is sign a predicate or just an off-switch? Both, and the two controls say different things

Within the delayed cell, most of the gain is duty cycle — a stratified random mask at matched
per-cell duty gets 0.209 → 0.039, and the predicate's positions add only 0.039 → 0.012 (genie),
0.053 → 0.033 (DD). But at matched frame-wide duty the shuffles lose 45/25/21 frames on the
fade — identical to the shipped arm — while sign/sign_dd recover the gap. The predicate's
value is cell targeting: off inside delayed-dominant dips, on everywhere else. Both controls
belong in the record; either alone misleads.

Note also: soft strictly dominates every gate where the gate fires (sign vs soft, paired per
seed: 0 fewer / 21 equal / 6 more). The gate earns its keep by not firing elsewhere. Paired counts,
lock-0/delayed: sign_dd vs hard 61 fewer / 10 equal / 0 more — outside any clustering.

Corrections to my previous comment

• I wrote that the 2×2 lock harness is "in mod carrier_dip_tiebreak (test(bpsk): #1363's three outstanding measurements, incl. the labelled ray split #1427)". It is not.
  git log -S'measure_lock_relative_to_dominant_tap' returns nothing (control: the same filter finds
  measure_snr_axis_tap_split_and_bytes in 0b770cd9). It exists only in an uncommitted branch.
  That was a straightforward attribution error.
• The found-lock distribution I gave (~96 % / ~77 % at lock 0, scattering in ~4 %) was the
  MODEL's, and I presented it as the chain's. Real chain, noise-free, 96 seeds:
  {0: 51, 1: 23, 2: 7, 3: 1, 4: 5, 5: 1, 7: 2, 8: 3, 10: 1, 12: 2} — 53 % at 0, 84 % within 0–2,
  16 % at ≥ 3, not 4 %. "The product lives in the lock-0 row" survives only if locks 1–2 count as
  aligned, which is the honest reading but needs saying.

Side finding, flagged not claimed

LS on a clean frame with zero delay spread puts the true composite β at 0.308, against the
shipped CROSSFADE_ISI_BETA = 1/3. That is ~8 % high. It wants its own check of the discrete window
sums before it is anything more than an observation.

What is still withheld

No fix recommendation. Before the word is used: the engine-level coded A/B through
combine_and_decode_llrs (real RS over all 255 bytes, scrambler, the same-chain instrument this
issue opened with); the BPSK31/63/100 twins and QPSK250-D, which this thread has already named and
which has no soft arm at all; and a design for the DD predicate's noise misfire, since 7.7 % false
firing is what costs the 37 frames at σ = 0.9.

lost throughout is >16 bad bytes over the 200 payload bytes of a 255-byte wire frame, no
scrambler, RS not actually run — a lower bound for every arm alike, not a decode rate.

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6