Skip to content

test(bpsk): #1363's three outstanding measurements, incl. the labelled ray split - #1427

Merged
dc0sk merged 1 commit into
mainfrom
investigate/1363-snr-axis-and-bytes
Sep 21, 2026
Merged

dc0sk merged 1 commit into
mainfrom
investigate/1363-snr-axis-and-bytes

Conversation

@dc0sk

@dc0sk dc0sk commented Sep 21, 2026

Copy link
Copy Markdown
Owner

Apparatus for #1363. Test-only; no production code changes. It lands the measurements behind
this comment so the
numbers stay reproducible, and it answers all three measurements that issue had outstanding.

mod carrier_dip_tiebreak gains:

  • ray_split — the two Watterson rays as complex values, labelled, without private access.
  • the_ray_split_agrees_with_the_envelope — default-run pin for it.
  • measure_snr_axis_tap_split_and_bytes#[ignore]d harness: SNR axis, payload-aligned byte
    counts, and the tap split.

The finding it produced

The cancellation costs 8 frames of 96 at every SNR, including noise-free, so no SNR-conditioned
mitigation can help. The harm localises to delayed-dominant mid-depth dips (noise-free,
|H| ∈ [0.05,0.20), err b0/b1):

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

A far sharper fix target than "the cancellation hurts on fades".

The split was recorded as impossible, and is not

ray_envelopes draws env0 then env1 before any noise sample and reads neither
delay_spread_ms nor snr_db, so one 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 it gives (e0−e1)/√2
(1.5 cycles → e^{−j3π} = −1). Magnitudes alone really are insufficient — that half of my argument
held — but the complex values are available, which I had not considered.

Two defects in my own apparatus, both caught by assertions rather than by reading

1. The pin first asserted E[|e|²] ≈ 1 per seed. One frame is a single Rayleigh realisation and
seed 0 reads 1.561/0.747, so it failed at once. The property is population-level; it is now a ratio
across seeds, with the per-seed spread recorded in the comment so nobody re-tightens it.

2. The worse one — the self-consistent-checker archetype. The pin re-derived the demixed
difference inline and compared that to carrier_envelope. That exercises the algebra but never
ray_split, so a planted dif * 0.5 inside the helper passed. Measured, not theorised.

Fixed by routing the pin through the helper and making the harness call the same function instead
of keeping a private copy. Sabotage-verified in both directions:

control (unmodified)        -> ok
dif * 0.5 inside ray_split  -> FAILED
   "the rays recovered by `ray_split` depart from `carrier_envelope` by 1.1306 over 9992 symbols"

The harness's numbers are identical before and after that refactor, so it is behaviour-preserving.

Retractions, on the issue

  • "Exactly 21 lost frames at all three SNRs" — a byte-alignment artefact. Grouping began 31
    bits before the payload's byte boundary and swept in preamble bytes; aligned it is 21/19/19/19,
    and the robust statement is the gap of 8.
  • "Soft improves while hard is pinned" — false. Both drop by 2 from 16→24 dB and neither moves
    to noise-free.
  • The deterministic deep-null limit is NOT refuted. Split by distance to the next true flip,
    d=1 rises 0.905 → 0.937 as noise is removed while d≥4 falls to 0.000 — the pooled plateau is the
    mechanism at finite |H|. "→ 1.0" was always a statement about H ≡ 0, which is measure zero.

Stated limits

The byte count covers 200 payload bytes of a 255-byte wire frame, so it is a lower bound for
both arms and is not a decode rate — do not equate 19/96 with the issue's opening 50/38. No
scrambler; RS is not actually run; deep-bin figures are clustered (nominal SE ≈ 0.03 per bit). The
next measurement is (lock × dominance) — dominance here is absolute, while the thread holds that
dominance relative to the timing lock is the real variable — and it is not done.

Test results

suites=339 tests_passed=2577 tests_failed=0
GATE: PASS 6b7d308e233585fa450d649b9c81af3077c74d79 clean 20260921T131458Z

All 13 steps ok. 2577 tests against main's 2576 — the one new default-run pin.

Refactors: CAP-12
Verification-objective: the apparatus behind a published measurement must be pinned by an assertion
that runs through the function the measurement calls

Review: none — this lands apparatus whose findings and write-up were reviewed before the issue
comment was posted; the review supplied the tap split, the alignment fix and the by-distance
breakdown, and its verdict is what this applies.

🤖 Generated with Claude Code

https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6

…d ray split

Test-only; no production code changes. `mod carrier_dip_tiebreak` gains `ray_split`
(the two Watterson rays as COMPLEX values, labelled, without private access), its
default-run pin `the_ray_split_agrees_with_the_envelope`, and
`measure_snr_axis_tap_split_and_bytes`, which answers all three measurements #1363 had
outstanding: an SNR axis, bytes rather than bits, and which tap dominates.

FINDING (posted to #1363): the cancellation costs 8 frames of 96 at EVERY SNR including
noise-free, so no SNR-conditioned mitigation can help; and the harm localises to
DELAYED-DOMINANT mid-depth dips, where the uncancelled arm reads 0.008/0.011 against
the cancelled arm's 0.236/0.114 while direct-dominant dips show the cancelled arm on
par or better.

THE SPLIT WAS RECORDED AS IMPOSSIBLE AND IS NOT. `ray_envelopes` draws env0 then env1
before any noise sample and reads neither delay_spread_ms nor snr_db, so one seed gives
identical rays under any delay; apply_complex at delay 0 with a DC probe gives
(e0+e1)/sqrt2 and at 1 ms with a complex 1500 Hz tone gives (e0-e1)/sqrt2. Magnitudes
alone really are insufficient — that half of my argument held — but the complex values
are available.

TWO DEFECTS IN MY OWN APPARATUS, both caught by assertions rather than by reading:
  * the pin first asserted E[|e|^2] ~ 1 PER SEED; one frame is a single Rayleigh
    realisation and seed 0 reads 1.561/0.747. The property is population-level and is
    now a ratio across seeds.
  * worse, and the self-consistent-checker archetype: the pin re-derived the demixed
    difference INLINE, so it exercised the algebra but never `ray_split`. Measured, a
    planted `dif * 0.5` inside the helper PASSED. The pin now runs through the helper
    and the harness calls the same function rather than keeping a private copy; the
    identical sabotage now fails at "depart from carrier_envelope by 1.1306 over 9992
    symbols" with the unmodified control passing.

Three of my own readings are retracted on the issue: "exactly 21 lost frames at all
three SNRs" was a byte-ALIGNMENT artefact (aligned: 21/19/19/19); "soft improves while
hard is pinned" is false; and the deterministic deep-null limit is NOT refuted — split
by distance to the next true flip, d=1 rises 0.905 -> 0.937 as noise is removed while
d>=4 falls to 0.000, so the pooled plateau IS the mechanism at finite |H|.

Limits carried into the issue rather than left implicit: the byte count covers 200
payload bytes of a 255-byte wire frame, so it is a lower bound for both arms and not a
decode rate; no scrambler; RS not actually run. Next measurement is (lock x dominance),
which is not done.

Refactors: CAP-12
Verification-objective: the apparatus behind a published measurement must be pinned by
an assertion that runs through the function the measurement calls

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0188ATCj6DZ9aRVQ2vSirua6
@dc0sk
dc0sk merged commit 0b770cd into main Sep 21, 2026
11 checks passed
@dc0sk
dc0sk deleted the investigate/1363-snr-axis-and-bytes branch September 21, 2026 17:44
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant