ashen-navigator/covcollab-eve-detection

Covert-Collaboration Eve-Detection Dataset

A controlled, balanced, reproducible benchmark for the covert-collaboration warden problem: decide whether a group of distributed users is secretly pooling messages into a coherent virtual-MIMO transmission — from the point of view of a passive eavesdropper, Eve.

Each example is one complex received block Y ∈ ℂ^{R×T} (R = 4 Eve antennas, T = 320 samples) labelled H1 (a collaboration signal is present) or H0 (receiver noise only, same noise model). The task is the binary hypothesis test H0 vs. H1 — detecting covert coordination — across six waveform families, three collaboration policies, an (M, K, d) system-size sweep, three channel conditions, and the full covert→detectable SNR range.

This is the controlled factorial companion to the on-the-fly training distribution used to train Universal Eve, a distributionally-robust learned warden. Where the streaming distribution randomizes everything, this artifact is a clean experimental object: every waveform format appears in equal amounts, and within each cell the three policy arms are generated over the same system so they differ only in the transmit policy.

At a glance

Samples	114,048 (balanced H0/H1)
Splits	train 82,944 · validation 10,368 · test_iid 10,368 · test_ood 10,368
Formats	sc, ofdm, dfts_ofdm, otfs, afdm, ofdm_comb — 19,008 each
Policy arms	none (no collaborative matrix), random, optimized — 38,016 each
Block shape	Y = (R, T) = (4, 320) complex64, stored as y_real / y_imag
Size	≈ 1.05 GiB (parquet, zstd)
Reproducible	bit-identical regeneration from the master seed (per-split SHA-256 in manifest.json)

Exact per-split / per-format / per-regime breakdowns live in manifest.json, the provenance record for the whole build.

The three collaboration arms (the core contrast)

For every (format, M, K, d, channel) cell the signal is generated under three policies that all share the same Frobenius power budget ‖W‖_F² = P_W = M, so the arms differ in structure, not received energy:

• none — no collaborative matrix. A diagonal message→antenna assignment (init_identity): component i on user i, no cross-user mixing, no beamforming. The honest "users don't collaborate covertly" baseline.
• random. A random feasible collaboration matrix W (fresh per group) — collaboration, but un-shaped.
• optimized. A PSGD sphericity-covert W that whitens Eve's received covariance subject to Bob's SINR floor J_B ≥ γ. Designed once per (format, M, Kd) on the flat channel (sphericity is a transmit-covariance property) and deployed across channels.

The optimized arm is measurably the most covert (lowest received non-sphericity); none/random leave exploitable second-order structure. This detectability gradient — at matched received power — is what the dataset teaches.

The sweep

• M (collaborating users): {8, 16, 25} multicarrier / {8, 12, 16} single-carrier (SC's ZC pilots cap orthogonal M at 16; both grids are length 3 → per-format counts stay equal).
• (K, d): {(2,1), (2,2), (4,1), (2,4)} → Kd ∈ {2, 4, 4, 8}. K and d are swept independently: (2,2) and (4,1) are distinct cells at the same Kd=4 (more users vs. longer messages).
• Channel (shared across arms in a cell): flat, multipath (4-tap exp-PDP), moderate Doppler (ε=0.10) for the IID core; strong Doppler (ε=0.25) is held out as test_ood.
• SNR / regime: Eve SNR over {-16,-12,-8,-4} dB; scenario Δ = SNR_E − SNR_B over {-20,-12,0,+6} dB, labelling each sample covert (Δ<0), **comparable** (|Δ|≤3), or **detectable** (Δ>0). Every split spans the full SNR grid and all three regimes.
• N_E fixed at 4 (a mid-strength warden); the N_E sweep lives in the streaming distribution.

Splits

Split is assigned by group, so a split's policy realizations are disjoint from the others (a test block is a genuinely unseen draw, not a re-noised training block):

• train / validation / test_iid — the IID core (flat / multipath / moderate-Doppler), 80/10/10 of groups. test_iid measures in-distribution generalization.
• test_ood — strong-Doppler cells (ε=0.25), a channel shift the training distribution explicitly excludes. Measures the out-of-distribution generalization the "universal" claim rests on. Still equal per format.

The multi_ne config — Eve's array size ($N_E$)

The default config fixes the warden at N_E = 4 antennas. The multi_ne config bakes in the orthogonal axis — N_E ∈ {1, 2, 4, 8} — to study how the warden's aperture changes both detection and structure fingerprinting. It sweeps N_E × format (6) × arm (3) × M ∈ {8,16} × channel, same group-level train/val/test_iid + strong-Doppler test_ood splits, equal per format, with the same 26-field schema.

Because R varies, every block is padded to R_max = 8 (y_real/y_imag length 8·320 = 2560; zstd compresses the zero-padding away), and the n_rx_eve column gives the valid antenna count — reshape to (8, 320) and use the first n_rx_eve antennas:

from datasets import load_dataset
import numpy as np
ds = load_dataset("<your-username>/covcollab-eve-detection", "multi_ne")
row = ds["train"][0]
Y8 = (np.array(row["y_real"], np.float32) + 1j*np.array(row["y_imag"], np.float32)).reshape(8, 320)
Y = Y8[:row["n_rx_eve"]]                     # valid antennas only

Provenance is in manifest_multi_ne.json (grid, splits, per-split Y SHA-256). Regenerate/verify with covcollab-eve-mne --materialize / --verify-materialized from the full covcollab repo (this config's generator uses the model code, so it is outside the minimal src/ bundle that regenerates the default config).

Finding (see the design note): both a larger array and more temporal looks lift the format/channel fingerprint (and a larger array sharply improves detection — spatial array gain), but neither recovers M or whether the covert policy is on — the covert design's structural hiding survives.

Usage

With 🤗 datasets

from datasets import load_dataset
import numpy as np

ds = load_dataset("<your-username>/covcollab-eve-detection")
row = ds["train"][0]
R, T = row["n_rx_eve"], row["n_samples_t"]                 # (4, 320)
Y = (np.array(row["y_real"], np.float32) + 1j*np.array(row["y_imag"], np.float32)).reshape(R, T)
label = row["label"]                                        # 1 = H1 (signal), 0 = H0 (noise)
print(Y.shape, Y.dtype, label, row["policy_arm"], row["format"], row["regime"])

Standalone loader (only pyarrow + numpy)

from covcollab_eve_loader import load_split, features_from_Y
d = load_split(".", "train")            # dict of numpy arrays; d["Y"] is (N, 4, 320) complex64
x = features_from_Y(d["Y"][:64])        # model input [Re, Im, |Y|^2] -> (64, 4, 3, 320) float32

The model input x = [Re(Y), Im(Y), |Y|²] is a deterministic function of Y (a per-minibatch energy scale), so features are not stored — recompute them with features_from_Y.

Training the Universal Eve warden

The repo also ships the trainer that consumes this dataset — a multi-task warden that jointly detects (H0/H1) and fingerprints (format, M, K, d, channel, policy-arm) — as covcollab-eve-mtl (src/covcollab/universaleve/multitask.py):

pip install -e ".[hf]"                              # numpy + torch + pyarrow
covcollab-eve-mtl --data . --regime both --out runs/mtl      # auto-selects cuda>mps>cpu

On an NVIDIA GPU, put the whole step (network and the complex FFT / covariance-eigenvalue feature extraction) on the card in complex64:

covcollab-eve-mtl --data . --regime both --device cuda --feat-device auto \
    --width 96 --batch 512 --steps 6000 --out runs/mtl_a100

See TRAINING.md for the full guide: the model, every CLI flag, the three training regimes (joint / detection-probe / multi-look), reproducing the fingerprinting map, and a detailed section on training on A100s and other NVIDIA GPUs (CUDA install, per-GPU batch/width settings, memory, multi-GPU, and expected wall-clock). For a runnable, end-to-end walkthrough (load → train → evaluate → the fingerprinting map, Colab-ready) open notebooks/train_universal_eve.ipynb.

Schema

Every sample carries y_real, y_imag, label, and a rich metadata row: split, format, policy_arm, policy_kind, n_tx (M), n_msg_users (K), msg_dim (d), kd, n_rx_eve, n_samples_t, eve_snr_db, bob_snr_db, delta_db, regime, policy_design_snr_db, channel_family, n_taps, nu_max, pdp_decay, noise_kind, nuisance, constellation, cell_id, group_id, base_seed. Full field meanings are in manifest.json → schema.

Bundled source (complete code + data)

This repo ships the complete covcollab package under src/covcollab/ — not just a subset. Alongside the dataset generator/loader you get the policy-design and channel CLIs, the learned-Eve architecture zoo, and the full Universal-Eve warden suite: the multi-task trainer (covcollab-eve-mtl) and the adversary-envelope studies (covcollab-eve-ladder, covcollab-eve-envelope, …), which synthesize signals on the fly. See src/SUBSET_NOTES.md and TRAINING.md. The snapshot corresponds to the git SHA in manifest.json, so the dataset can be regenerated, verified, trained on, and extended from the repo itself, with no external checkout:

pip install ".[hf]"           # installs numpy + torch + matplotlib (+ pyarrow for parquet)
covcollab-eve-controlled --verify --out .
covcollab-eve-envelope --axis all     # the adversary-envelope depth study (synthesizes data)

Note the standalone covcollab_eve_loader.py needs only pyarrow + numpy — you do not need to install the package just to load the data.

Reproduce / verify

The dataset is a pure function of the master seed. To regenerate and to assert bit-identity:

# regenerate (parquet + manifest, a few minutes on a laptop CPU)
covcollab-eve-controlled --out . \
    --base-seed 7000 --per 16 --groups-core 10 --groups-ood 3 --opt-steps 40 --opt-batch 96

# assert the stored per-split SHA-256 of Y regenerates bit-for-bit
covcollab-eve-controlled --verify --out .

# refresh the bundled source snapshot (full src/ + a portable pyproject.toml)
covcollab-eve-controlled --bundle-source --full-source --out .

(Prefix with uv run --extra hf if you use uv instead of a plain install.) The generation pipeline, a walkthrough of every format, and the representativeness analysis are in notebooks/generate_dataset.ipynb.

What it does not vary

Deliberately fixed here (and covered by the streaming training distribution / companion analyses): colored & impulsive receiver noise, N_E ≠ 4, and per-user oscillator / coordination signatures. This keeps the factorial clean; robustness to those factors is studied separately.

Provenance & reproducibility caveat

manifest.json records the git SHA, numpy/torch versions, platform, the full grid, the split policy, and the per-split Y SHA-256. Bit-identity holds within the pinned environment — float reductions are BLAS-dependent, so cross-machine bit-identity is not claimed; --verify asserts it on the build machine.

License

Released under CC-BY-4.0. If you use this dataset, please cite the covert-collaboration project.