Ciphertext-only family enumeration, and checks that reproduce off a GPU

check_family_enum.py measures the attack the manuscript now states in
Section III-A: the winning correlation is an index-free verifier, so
ranking the 63 non-constant Walsh rows by mean winning correlation
recovers the user set from one frame in 0.905 of 200 trials at 10 dB
and from four frames in 0.990, using nothing outside the stated threat
model. Under the invariance refresh it recovers it in none, because the
entry permutation relabels the codebook the adversary must align
against.

V8 and V9 read the trained codebook through main_model(), which
retrains on every call, and a codebook trained on CUDA is not the one
trained on CPU. The shipped verify_math.csv therefore read PASS here
and FAIL for anyone running this package without a GPU. model_main.pt
is 7 KB and fixes the codebook, which is what both checks are about;
delete it to retrain. V1-V11 now pass on both.

New checks: V10, the format-matched OMA reference Section VI-B quotes,
and V11, the closed-form against Monte Carlo comparison the manuscript
claimed and never stored. V3a's bias-linearity result was computed and
printed but never written to the CSV, so the one linearity claim the
paper quotes was the one this package could not show.

check_consistency.py gains 21 assertions, covering five data files that
no assertion read (users, csi, semantic, cov_attack, sec_jam) and the
trend claims it structurally could not see, since it compared values
and not shapes.

README: the figure map named stages that do not write the artifacts
they list, so following it did not reproduce Figs. 4 and 6; the
reproduction block was five scripts short; and the refresh numbers were
from a superseded run (nearly three, 15.0 to 64.8 bits) against the
manuscript's 2.3 and 23.8 to 364.6.

README.md

@@ -31,7 +31,7 @@ code/
   exp_permkpa.py        permutation-key known-plaintext attack (Fig. 7)
   check_cov_*.py        ciphertext-only covariance-attack checks (referee M1)
   exp_real_sec.py       stage G: real BERT WordPiece token streams
-  verify_math.py        closed-form checks V1-V5, PASS/FAIL and verify_math.csv
+  verify_math.py        closed-form checks V1-V11, PASS/FAIL and verify_math.csv
   replot_security.py    every result figure, from data/ to fig/
   make_tables.py        LaTeX rows of every result table, from data/
   feasibility_security.py   early CPU-sized study, kept for the record
@@ -53,6 +53,12 @@ python exp_full.py           # stages A-F and L
 python exp_kpa.py            # known-plaintext attack
 python exp_refresh.py        # the key-refresh layer
 python exp_real_sec.py       # real token streams
+python exp_permkpa.py        # permutation-key known plaintext
+python exp_infotheory.py     # mutual information and equivocation
+python exp_semantic.py       # semantic-similarity leakage
+python exp_users_csi.py      # load and channel-estimate sweeps
+python check_cov_attack.py   # ciphertext-only covariance attack
+python check_family_enum.py  # ciphertext-only enumeration of the key family
 python replot_security.py    # all figures from the CSVs
 python make_tables.py        # LaTeX rows of the result tables
 ```
@@ -77,9 +83,9 @@ Logarithms in an entropy or an information rate are base two.
 |---|---|---|
 | Fig. 2 SER against SNR | `exp_full.stage_A` | `sec_snr.csv` |
 | Fig. 3 key length | `exp_full.stage_B` | `sec_keylen.csv` |
-| Fig. 4 jamming (4 schemes) | `exp_full.stage_L` | `sec_jam_cmp.csv`, `sec_jam.csv` |
+| Fig. 4 jamming (4 schemes) | `exp_full.stage_C`, `stage_L` | `sec_jam_cmp.csv`, `sec_jam.csv` |
 | Fig. 5 key sensitivity | `exp_full.stage_I` | `sec_sens_cmp.csv` |
-| Fig. 6 brute-force search | `exp_full.stage_J` | `sec_brute_cmp.csv`, `sec_brute.csv` |
+| Fig. 6 brute-force search | `exp_full.stage_I`, `stage_F`, `stage_J` | `sec_brute_cmp.csv`, `sec_brute.csv` |
 | Fig. 7 known-plaintext attack | `exp_kpa`, `exp_permkpa` | `kpa.csv`, `pkpa.csv` |
 | Fig. 8 real token streams | `exp_real_sec` | `real_sec_ter.csv` |
 | Scheme comparison table | `exp_full.stage_E` | `sec_compare.csv` |
@@ -103,8 +109,8 @@ measures. The key must therefore be refreshed per coherence block from a shared
 seed. `exp_refresh.py` implements that layer and shows why it has to
 draw from the transformations that leave the decision statistic
 invariant: a refresh that installs fresh orthogonal keys instead costs
-the legitimate users a factor of nearly three, while the invariant
-refresh costs nothing and raises the per-block key from 15.0 to 64.8
+the legitimate users a factor of 2.3, while the invariant
+refresh costs nothing and raises the per-block key from 23.8 to 364.6
 bits.
 
 ## License