Simulation code and data for the TMC submission

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.DS_Store

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ki-Ho Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,61 @@
+# Structured Shared–Private Embedding Multiplexing
+
+Simulation code and data for the manuscript
+
+> K.-H. Lee, H.-H. Choi, and J.-R. Lee, "Structured Shared–Private
+> Embedding Multiplexing for Semantic Multiple Access in Dynamic Mobile
+> Networks," submitted to *IEEE Transactions on Mobile Computing*, 2026.
+
+Builds on the published shared-embedding multiple-access framework
+(Lee, Choi, Lee, *IEEE JSAC*, vol. 44, 2026, doi 10.1109/JSAC.2025.3643816).
+
+## Layout
+
+- `code/semantic_mac.py` — core library (content model, matched-filter
+  front end, SR/SC/LMMSE/DR receivers, spectral structure recovery,
+  mobility model, affinity tracker)
+- `code/exp1_theory.py` — E1: receiver theory validation (affinity and
+  SNR sweeps, closed-form overlays) → `data/e1_*.csv`
+- `code/exp2_structure.py` — E2: embedding-structure optimization on
+  real BERT embeddings (spectral recovery, learned adapter, held-out
+  evaluation ladder) → `data/e2_*.csv`, `data/e2_exponents.txt`
+- `code/exp3_mobility.py` — E3: time-varying affinity tracking under
+  mobility (scene traversal and speed sweep) → `data/e3_*.csv`
+- `code/exp4_mismatch.py` — E4: robustness to affinity estimation
+  error → `data/e4_mismatch.csv`
+- `code/exp5_learned.py` — E5: comparison with a trained user-wise
+  attention receiver → `data/e5_learned.csv`, `data/e5_train_log.csv`
+- `code/check_mask_realization.py` — realized Haar-mask front end vs
+  the expected cross-Gram model → `data/e_mask_check.csv`
+- `code/replot_all.py` — the single canonical figure generator; reads
+  only `data/*.csv` and writes every paper figure with a uniform
+  canvas geometry
+- `code/lmmse_verify.py` — early derivation-check prototype for the
+  affinity-aware LMMSE proposition (predecessor of E1)
+- `data/bert_agnews_8000.pt` — frozen `bert-base-uncased` mean-pooled
+  embeddings of 8,000 AG News sentences (768-dim), the real-content
+  pool used by E2
+
+## Reproduction
+
+Requirements: Python 3.10+, `numpy`, `torch` (CPU is sufficient),
+`matplotlib`.
+
+```bash
+cd code
+python exp1_theory.py      # E1  (minutes)
+python exp2_structure.py   # E2  (about an hour on CPU)
+python exp3_mobility.py    # E3  (about an hour on CPU)
+python exp4_mismatch.py    # E4  (minutes)
+python exp5_learned.py     # E5  (minutes)
+python replot_all.py       # regenerate every figure from data/*.csv
+```
+
+Every experiment fixes its random seeds, experiment scripts write CSVs
+only, and `replot_all.py` is the only script that produces figures, so
+each figure in the paper is regenerable from the shipped CSVs without
+rerunning the experiments.
+
+## License
+
+MIT — see `LICENSE`.

code/check_mask_realization.py

@@ -0,0 +1,110 @@
+"""Mask-realization check: the paper's experiments generate the
+matched-filter outputs from the EXPECTED cross-Gram model
+(semantic_mac.matched_filter). This script draws actual Haar-mixture
+masks, passes the physical superposition r = sum_v h_v M_v x_v + n
+through the realized masks, applies the same receivers, and compares
+the SER against the expectation-model front end on identical latents,
+gains, and noise seeds.
+
+The realized per-entry Gram deviation is O(1/sqrt(d)); this check
+quantifies its end-to-end effect at d=64 (theory/mobility setting) and
+d=768 (real-embedding setting).
+
+Outputs: data/e_mask_check.csv
+"""
+import math
+import os
+import numpy as np
+
+from semantic_mac import (affinity_matrix, matched_filter, demux_sr,
+                          demux_sc, demux_lmmse, demux_dr,
+                          sample_latents_isotropic, random_orthogonal,
+                          metrics)
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+DATA = os.path.join(HERE, "..", "data")
+
+U = 4
+BETA = 0.5
+
+
+def haar_masks(B, d, rng):
+    """M_u = sum_k A_uk U_k with A = chol(B), U_k independent Haar."""
+    A = np.linalg.cholesky(B)
+    Us = [random_orthogonal(d, rng) for _ in range(U)]
+    return [sum(A[u, k] * Us[k] for k in range(U)) for u in range(U)]
+
+
+def physical_front_end(z, h, Ms, rho, rng):
+    """r = sum_v h_v M_v z_v + n (ambient AWGN), tilde_u = M_u^T r / h_u."""
+    batch, Uu, d = z.shape
+    sigma = math.sqrt(1.0 / rho)
+    r = np.einsum('bv,vde,bve->bd', h,
+                  np.stack(Ms), z) + rng.standard_normal((batch, d)) * sigma
+    tilde = np.stack([(r @ Ms[u]) / h[:, u][:, None] for u in range(U)],
+                     axis=1)
+    return tilde
+
+
+def run(d, d_c, batch, n_mask_draws, snr_db):
+    RHO = 10 ** (snr_db / 10)
+    a = math.sqrt(BETA) * np.ones(U)
+    B = affinity_matrix(a)
+    Vc = np.eye(d)[:, :d_c]
+    diffs = {m: [] for m in ("SR", "SC", "LMMSE", "DR")}
+    sers_r = {m: [] for m in diffs}
+    sers_e = {m: [] for m in diffs}
+    for t in range(n_mask_draws):
+        rng = np.random.default_rng(7700 + 10 * t)
+        z = sample_latents_isotropic(batch, U, d, d_c, a, rng)
+        hc = (rng.standard_normal((batch, U)) +
+              1j * rng.standard_normal((batch, U))) / math.sqrt(2)
+        h = np.clip(np.abs(hc), 0.2, None)
+        Ms = haar_masks(B, d, rng)
+        gram_dev = max(np.abs(Ms[u].T @ Ms[v] - B[u, v] * np.eye(d)).max()
+                       for u in range(U) for v in range(U))
+        tilde_r = physical_front_end(z, h, Ms, RHO, rng)
+        # expectation-model front end on the SAME latents and gains
+        rng_e = np.random.default_rng(8800 + 10 * t)
+        tilde_e = np.einsum('uv,bvd,bv,bu->bud', B, z, h, 1.0 / h)
+        xi = rng_e.standard_normal((batch, U, d)) * math.sqrt(1.0 / RHO)
+        A = np.linalg.cholesky(B)
+        for b in range(batch):
+            tilde_e[b] += (A @ xi[b]) / h[b][:, None]
+        for name, tl in (("realized", tilde_r), ("expected", tilde_e)):
+            out = {}
+            out["SR"] = demux_sr(tl, B, h)
+            out["SC"] = demux_sc(tl, h)
+            out["LMMSE"], _ = demux_lmmse(tl, B, h, RHO)
+            out["DR"] = demux_dr(tl, B, h, RHO, a, Vc)
+            for m in diffs:
+                _, _, s = metrics(out[m], z)
+                (sers_r if name == "realized" else sers_e)[m].append(s)
+        for m in diffs:
+            diffs[m].append(sers_r[m][-1] - sers_e[m][-1])
+        print(f"d={d} draw {t+1}/{n_mask_draws} gram_dev={gram_dev:.3f} "
+              + " ".join(f"{m}:d={diffs[m][-1]:+.4f}" for m in diffs))
+    return {m: (float(np.mean(sers_r[m])), float(np.mean(sers_e[m])),
+                float(np.mean(diffs[m])), float(np.std(diffs[m])))
+            for m in diffs}
+
+
+def main():
+    rows = []
+    for d, d_c, batch, draws, snr_db in ((64, 16, 2000, 12, 10),
+                                         (768, 128, 400, 6, 20)):
+        res = run(d, d_c, batch, draws, snr_db)
+        for m, (sr, se, md, sd) in res.items():
+            rows.append((d, snr_db, m, sr, se, md, sd))
+            print(f"d={d} snr={snr_db} {m}: realized={sr:.4f} "
+                  f"expected={se:.4f} mean_diff={md:+.5f} std={sd:.5f}")
+    with open(os.path.join(DATA, "e_mask_check.csv"), "w") as f:
+        f.write("d,snr,method,ser_realized,ser_expected,mean_diff,"
+                "std_diff\n")
+        for r in rows:
+            f.write(",".join(str(x) for x in r) + "\n")
+    print("mask check done.")
+
+
+if __name__ == "__main__":
+    main()

code/exp1_theory.py

@@ -0,0 +1,107 @@
+"""E1: receiver theory verification (synthetic isotropic contents).
+
+Outputs: data/e1_beta.csv, data/e1_snr.csv, data/e1_endpoints.txt
+(figures come from replot_all.py only)
+"""
+import math
+import os
+import numpy as np
+from semantic_mac import (affinity_matrix, matched_filter, demux_sr, demux_sc,
+                          demux_lmmse, demux_dr, lmmse_matrices,
+                          sample_latents_isotropic, metrics,
+                          oma_observe, demux_noma_genie)
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIG = os.path.join(HERE, "..", "fig")
+DATA = os.path.join(HERE, "..", "data")
+os.makedirs(FIG, exist_ok=True)
+os.makedirs(DATA, exist_ok=True)
+
+U, D, DC = 4, 64, 16
+BATCH = 4000
+NAMES = ["OMA", "NOMA", "SR", "SC", "LMMSE", "DR"]
+
+
+def run_point(beta, rho, rng, conv_seed=0):
+    a = math.sqrt(beta) * np.ones(U)
+    B = affinity_matrix(a)
+    z = sample_latents_isotropic(BATCH, U, D, DC, a, rng)
+    tilde, h = matched_filter(z, B, rho, rng)
+    Vc = np.eye(D)[:, :DC]
+    res = {}
+    res["SR"] = metrics(demux_sr(tilde, B, h), z)
+    res["SC"] = metrics(demux_sc(tilde, h), z)
+    lm, cf = demux_lmmse(tilde, B, h, rho)
+    res["LMMSE"] = metrics(lm, z)
+    res["LMMSE_cf"] = float(cf.mean())
+    # SR closed form: d sigma^2 [B^-1]_uu / h^2 averaged
+    Binv = np.diag(np.linalg.inv(B))
+    res["SR_cf"] = float((D / rho) * (Binv[None, :] / h ** 2).mean())
+    res["DR"] = metrics(demux_dr(tilde, B, h, rho, a, Vc), z)
+    # conventional baselines on a dedicated stream (keeps main draws intact)
+    rng_c = np.random.default_rng(90000 + conv_seed)
+    res["OMA"] = metrics(oma_observe(z, h, rho, rng_c), z)
+    res["NOMA"] = metrics(demux_noma_genie(z, h, rho, rng_c), z)
+    return res
+
+
+def main():
+    rng = np.random.default_rng(0)
+    rho_db = 10
+    rho = 10 ** (rho_db / 10)
+    betas = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99]
+    rows = []
+    for b in betas:
+        r = run_point(b, rho, rng, conv_seed=int(b * 100))
+        rows.append(r)
+        print(f"beta={b:4.2f} " + " ".join(
+            f"{n}:cos={r[n][0]:.3f},nmse={r[n][1]:.3f},ser={r[n][2]:.3f}"
+            for n in NAMES))
+    with open(os.path.join(DATA, "e1_beta.csv"), "w") as f:
+        f.write("beta," + ",".join(f"{n}_cos,{n}_nmse,{n}_ser" for n in NAMES)
+                + ",LMMSE_cf,SR_cf\n")
+        for b, r in zip(betas, rows):
+            f.write(f"{b}," + ",".join(
+                f"{r[n][0]},{r[n][1]},{r[n][2]}" for n in NAMES)
+                + f",{r['LMMSE_cf']},{r['SR_cf']}\n")
+
+    beta_mid = 0.4
+    snrs = list(range(0, 21, 4))
+    rows_s = []
+    for s in snrs:
+        r = run_point(beta_mid, 10 ** (s / 10), rng, conv_seed=1000 + s)
+        rows_s.append(r)
+        print(f"snr={s} " + " ".join(f"{n}:ser={r[n][2]:.3f}" for n in NAMES))
+    with open(os.path.join(DATA, "e1_snr.csv"), "w") as f:
+        f.write("snr," + ",".join(f"{n}_cos,{n}_nmse,{n}_ser" for n in NAMES) + "\n")
+        for s, r in zip(snrs, rows_s):
+            f.write(f"{s}," + ",".join(
+                f"{r[n][0]},{r[n][1]},{r[n][2]}" for n in NAMES) + "\n")
+
+    # endpoint checks
+    lines = []
+    a = math.sqrt(0.4) * np.ones(U)
+    B = affinity_matrix(a)
+    h = np.clip(np.abs((rng.standard_normal(U) + 1j * rng.standard_normal(U))
+                       / math.sqrt(2)), 0.2, None)
+    for rdb in (10, 40, 80):
+        W, _ = lmmse_matrices(B, h, 10 ** (-rdb / 10), D)
+        Ginv = np.linalg.inv(np.diag(1 / h) @ B @ np.diag(h))
+        rel = np.linalg.norm(W - Ginv) / np.linalg.norm(Ginv)
+        lines.append(f"(i) rho={rdb}dB rel_diff_W_vs_Gammainv={rel:.3e}")
+    W0, _ = lmmse_matrices(np.eye(U), h, 0.1, D)
+    off = np.abs(W0 - np.diag(np.diag(W0))).max()
+    wiener = h ** 2 / (h ** 2 + D * 0.1)
+    lines.append(f"(ii) beta=0 max_offdiag={off:.3e} "
+                 f"max_diag_minus_wiener={np.abs(np.diag(W0)-wiener).max():.3e}")
+    with open(os.path.join(DATA, "e1_endpoints.txt"), "w") as f:
+        f.write("\n".join(lines) + "\n")
+    print("\n".join(lines))
+
+    # figures are produced only by the canonical replot_all.py (uniform
+    # geometry); experiment scripts write CSVs exclusively.
+    print("E1 done. Run replot_all.py to regenerate the figures.")
+
+
+if __name__ == "__main__":
+    main()

code/exp2_structure.py

@@ -0,0 +1,244 @@
+"""E2: embedding-structure optimization on REAL PLM embeddings.
+
+Contents are real BERT AG-News embeddings (8000 x 768, from the published
+shared-embedding line); the structured latent is mixed by an unknown random
+orthogonal R (the frozen encoder's arbitrary basis).  We compare:
+
+  (i)   LMMSE            -- B-aware optimal linear receiver, no structure
+  (ii)  DR + spectral    -- closed-form shared-subspace recovery from N pairs
+  (iii) DR + adapter     -- channel-in-the-loop learned linear refinement
+  (iv)  DR + oracle      -- true mixing basis (upper bound)
+
+Calibration, adapter training, and subspace/spectrum sweeps draw only from
+the first 7000 pool sentences; the performance ladder is evaluated on
+tuples drawn from the held-out remaining 1000 sentences.
+
+Outputs: data/e2_subspace_multi.csv, data/e2_spectrum_multi.csv,
+data/e2_exponents.txt, data/e2_caliberr.txt, data/e2_ladder.csv
+(figures come from replot_all.py only)
+"""
+import math
+import os
+import numpy as np
+import torch
+
+from semantic_mac import (EmbeddingPool, affinity_matrix, matched_filter,
+                          demux_lmmse, demux_dr, sample_latents_pool,
+                          random_orthogonal, learn_structure_spectral,
+                          subspace_error, metrics,
+                          oma_observe, demux_noma_genie)
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIG = os.path.join(HERE, "..", "fig")
+DATA = os.path.join(HERE, "..", "data")
+os.makedirs(FIG, exist_ok=True)
+os.makedirs(DATA, exist_ok=True)
+
+# BERT AG-News embedding pool: shipped in data/ for the public release,
+# with a fallback to the original location in the paper workspace.
+POOL_PT = os.path.join(HERE, "..", "data", "bert_agnews_8000.pt")
+if not os.path.exists(POOL_PT):
+    POOL_PT = os.path.join(HERE, "..", "..", "5. WCL-DRL",
+                           "bert_agnews_8000.pt")
+U, D, DC = 4, 768, 128
+BETA = 0.5
+N_PAIR = 200          # paired calibration samples available to the optimizer
+BATCH_EVAL = 4000
+N_TRAIN_POOL = 7000   # sentences usable for calibration/adapter training
+# evaluation tuples are drawn only from the held-out remainder of the pool
+IDX_TRAIN = np.arange(N_TRAIN_POOL)
+IDX_EVAL = np.arange(N_TRAIN_POOL, 8000)
+
+
+def gen_clean(pool, n, a, R, rng, idx_pool=None):
+    z = sample_latents_pool(pool, n, U, D, DC, a, rng, idx_pool=idx_pool)
+    return z, z @ R.T
+
+
+# ----------------------------------------------------------------------
+#  Learned linear adapter (channel-in-the-loop refinement)
+# ----------------------------------------------------------------------
+def dr_torch(tilde, B, h, rho, a, W, d_c):
+    """Differentiable decomposition receiver in the adapter frame W (d x d).
+    Returns ambient-frame estimates W^T z_hat."""
+    Bt, Ut, d = tilde.shape
+    sigma2 = 1.0 / rho
+    y = tilde @ W.T                                   # rotated MF outputs
+    Zs, Zp = y[:, :, :d_c], y[:, :, d_c:]
+    Hi = torch.diag_embed(1.0 / h)
+    Hm = torch.diag_embed(h)
+    Bb = B.unsqueeze(0).expand(Bt, Ut, Ut)
+    Gamma = Hi @ Bb @ Hm
+    Cn = sigma2 * (Hi @ Bb @ Hi)
+    ratio = h.unsqueeze(1) / h.unsqueeze(2)           # h_v / h_u
+    gamma = a.view(1, 1, Ut) * Bb * ratio
+    gamma = gamma.sum(dim=2) - (a.view(1, Ut) * (Bb.diagonal(dim1=1, dim2=2) - 1.0))
+    # gamma_u = a_u + sum_{v != u} B_uv a_v h_v/h_u  (diagonal of Bb is 1)
+    Cn_inv = torch.linalg.inv(Cn)
+    gCg = torch.einsum('bu,buv,bv->b', gamma, Cn_inv, gamma).clamp_min(1e-9)
+    c_hat = torch.einsum('bu,buv,bvk->bk', gamma, Cn_inv, Zs) / gCg.unsqueeze(-1)
+    shrink_c = (1.0 / d_c) / (1.0 / d_c + 1.0 / gCg)
+    c_hat = c_hat * shrink_c.unsqueeze(-1)
+    Gp = torch.linalg.solve(Gamma, Zp)
+    Binv_uu = torch.linalg.inv(B).diagonal()
+    sig_p = (1.0 - a ** 2).clamp_min(1e-9)
+    err_p = (d - d_c) * sigma2 * Binv_uu.view(1, Ut) / (h ** 2)
+    shrink_p = sig_p.view(1, Ut) / (sig_p.view(1, Ut) + err_p)
+    z_hat = torch.cat([
+        a.view(1, Ut, 1) * c_hat.unsqueeze(1).expand(Bt, Ut, d_c),
+        shrink_p.unsqueeze(-1) * Gp], dim=2)
+    return z_hat @ W                                  # back to ambient frame
+
+
+def train_adapter(x_cal, a, V_init, rng, steps=400, batch=24, lr=3e-4,
+                  lam_orth=1.0, lam_align=0.2, seed=0):
+    """Refine the full rotation W (init = spectral basis) through the channel.
+
+    x_cal: the SAME N_PAIR calibration embeddings used by the spectral
+    estimator (the adapter adds no data cost, as stated in the paper)."""
+    torch.manual_seed(seed)
+    W = torch.nn.Parameter(torch.tensor(V_init.T, dtype=torch.float32))
+    a_t = torch.tensor(a, dtype=torch.float32)
+    B_np = affinity_matrix(a)
+    B_t = torch.tensor(B_np, dtype=torch.float32)
+    opt = torch.optim.Adam([W], lr=lr)
+    n_cal = x_cal.shape[0]
+    x_cal_t = torch.tensor(x_cal, dtype=torch.float32)
+    for it in range(steps):
+        idx = torch.randint(0, n_cal, (batch,))
+        x = x_cal_t[idx]
+        snr_db = float(rng.uniform(0, 20))
+        rho = 10 ** (snr_db / 10)
+        tilde_np, h_np = matched_filter(x.numpy().astype(np.float64),
+                                        B_np, rho, rng)
+        tilde = torch.tensor(tilde_np, dtype=torch.float32)
+        h = torch.tensor(h_np, dtype=torch.float32)
+        x_hat = dr_torch(tilde, B_t, h, rho, a_t, W, DC)
+        cosd = 1.0 - torch.nn.functional.cosine_similarity(
+            x_hat, x, dim=2).mean()
+        y = x @ W.T
+        s = torch.nn.functional.normalize(y[:, :, :DC], dim=2)
+        align = (s.unsqueeze(1) - s.unsqueeze(2)).pow(2).sum(-1).mean()
+        orth = (W @ W.T - torch.eye(D)).pow(2).mean()
+        loss = cosd + lam_align * align + lam_orth * orth
+        opt.zero_grad()
+        loss.backward()
+        opt.step()
+        if (it + 1) % 100 == 0:
+            print(f"  adapter step {it+1}: loss={loss.item():.4f} "
+                  f"cosd={cosd.item():.4f} align={align.item():.4f}")
+    with torch.no_grad():
+        # re-orthonormalize
+        Uo, _, Vo = torch.linalg.svd(W)
+        Wo = Uo @ Vo
+    return Wo.numpy().astype(np.float64)
+
+
+def main():
+    rng = np.random.default_rng(7)
+    obj = torch.load(POOL_PT, map_location="cpu")
+    X = obj.numpy() if torch.is_tensor(obj) else np.asarray(obj)
+    pool = EmbeddingPool(X)
+    print(f"pool: {pool.N} x {pool.d}")
+    a = math.sqrt(BETA) * np.ones(U)
+    B = affinity_matrix(a)
+    R = random_orthogonal(D, rng)
+    V_true = R[:, :DC]
+
+    # --- subspace recovery vs N for multiple user counts ------------------
+    # Multi-trial averaging; the N grid starts above d_c = 128 because for
+    # N < d_c the empirical cross-covariance is rank-deficient in the shared
+    # block (at most N of the d_c shared directions are excited), which
+    # produces a systematic plateau rather than smooth decay.
+    TRIALS = 12
+    Ns = [200, 400, 800, 1600, 3200, 6400]
+    err_multi = {}
+    with open(os.path.join(DATA, "e2_subspace_multi.csv"), "w") as f:
+        f.write("U,N,err\n")
+        for Um in (2, 4, 8):
+            a_u = math.sqrt(BETA) * np.ones(Um)
+            err_multi[Um] = []
+            for n in Ns:
+                errs_t = []
+                for t in range(TRIALS):
+                    rng_t = np.random.default_rng(42000 + 1000 * Um
+                                                  + 10 * n + t)
+                    z_u = sample_latents_pool(pool, n, Um, D, DC, a_u, rng_t,
+                                              idx_pool=IDX_TRAIN)
+                    Vh, _ = learn_structure_spectral(z_u @ R.T, DC)
+                    errs_t.append(subspace_error(Vh, V_true))
+                e_u = float(np.mean(errs_t))
+                err_multi[Um].append(e_u)
+                f.write(f"{Um},{n},{e_u}\n")
+                print(f"U={Um} N={n:5d} err={e_u:.4f} "
+                      f"(std {np.std(errs_t):.4f})")
+
+    # power-law exponents of the subspace-error decay (quoted in the paper)
+    with open(os.path.join(DATA, "e2_exponents.txt"), "w") as f:
+        for Um in (2, 4, 8):
+            slope = np.polyfit(np.log(Ns), np.log(err_multi[Um]), 1)[0]
+            f.write(f"U={Um} exponent={slope:.3f}\n")
+            print(f"U={Um} power-law exponent {slope:.3f}")
+
+    # --- eigen-spectrum for several calibration sizes (fresh rng) ---------
+    with open(os.path.join(DATA, "e2_spectrum_multi.csv"), "w") as f:
+        f.write("N,idx,eig\n")
+        for n in (100, 400, 1600):
+            rng_s = np.random.default_rng(5200 + n)
+            z_s = sample_latents_pool(pool, n, U, D, DC, a, rng_s,
+                                      idx_pool=IDX_TRAIN)
+            _, ev = learn_structure_spectral(z_s @ R.T, DC)
+            for i, w in enumerate(ev[:400]):
+                f.write(f"{n},{i+1},{w}\n")
+
+    # --- calibration with the paper budget --------------------------------
+    _, x_cal = gen_clean(pool, N_PAIR, a, R, rng, idx_pool=IDX_TRAIN)
+    V_spec, _ = learn_structure_spectral(x_cal, DC)
+    err_spec = subspace_error(V_spec, V_true)
+    print(f"spectral (N={N_PAIR}): subspace_err={err_spec:.4f}")
+
+    # full basis for adapter init: complete V_spec to an orthonormal basis
+    Q, _ = np.linalg.qr(np.hstack([
+        V_spec, rng.standard_normal((D, D - DC))]))
+    V_full = Q
+    print("training adapter (same calibration pairs as the spectral step) ...")
+    W_ad = train_adapter(x_cal, a, V_full, rng)
+    err_ad = subspace_error(W_ad.T[:, :DC], V_true)
+    print(f"adapter: subspace_err={err_ad:.4f}")
+    with open(os.path.join(DATA, "e2_caliberr.txt"), "w") as f:
+        f.write(f"spectral_err={err_spec}\nadapter_err={err_ad}\n")
+
+    # --- performance ladder vs SNR (held-out pool sentences) ---------------
+    snrs = list(range(0, 21, 4))
+    rows = []
+    for s in snrs:
+        rho = 10 ** (s / 10)
+        z, x = gen_clean(pool, BATCH_EVAL, a, R, rng, idx_pool=IDX_EVAL)
+        tilde, h = matched_filter(x, B, rho, rng)
+        r = {}
+        lm, _ = demux_lmmse(tilde, B, h, rho)
+        r["LMMSE"] = metrics(lm, x)
+        r["DR-spec"] = metrics(demux_dr(tilde, B, h, rho, a, V_spec), x)
+        r["DR-adapt"] = metrics(
+            demux_dr(tilde, B, h, rho, a, W_ad.T[:, :DC]), x)
+        r["DR-oracle"] = metrics(demux_dr(tilde, B, h, rho, a, V_true), x)
+        rng_c = np.random.default_rng(91000 + s)
+        r["OMA"] = metrics(oma_observe(x, h, rho, rng_c), x)
+        r["NOMA"] = metrics(demux_noma_genie(x, h, rho, rng_c), x)
+        rows.append(r)
+        print(f"snr={s:2d} " + " ".join(
+            f"{k}:cos={v[0]:.3f},ser={v[2]:.3f}" for k, v in r.items()))
+    keys = ["OMA", "NOMA", "LMMSE", "DR-spec", "DR-adapt", "DR-oracle"]
+    with open(os.path.join(DATA, "e2_ladder.csv"), "w") as f:
+        f.write("snr," + ",".join(f"{k}_cos,{k}_nmse,{k}_ser" for k in keys) + "\n")
+        for s, r in zip(snrs, rows):
+            f.write(f"{s}," + ",".join(
+                f"{r[k][0]},{r[k][1]},{r[k][2]}" for k in keys) + "\n")
+
+    # figures are produced only by the canonical replot_all.py (uniform
+    # geometry); experiment scripts write CSVs exclusively.
+    print("E2 done. Run replot_all.py to regenerate the figures.")
+
+
+if __name__ == "__main__":
+    main()

code/exp3_mobility.py

@@ -0,0 +1,161 @@
+"""E3: dynamic mobile environment -- time-varying share coefficients a_u(t)
+from random-waypoint trajectories, with sparse affinity-pilot tracking.
+
+Every K-th slot each user sends n_p orthogonal pilot embeddings (overhead
+n_p/(K*batch) << 1); the tracker EWMA-smooths the triangulated observations.
+
+Methods:
+  DR-genie   : decomposition receiver with true a_u(t)         (upper ref)
+  DR-tracked : DR with pilot-tracked a_hat(t)                  (proposed)
+  DR-static  : DR designed for the time-averaged a (no adaptation)
+  SR / SC / LMMSE : baselines with true B(t)
+
+Outputs: data/e3_timeseries.csv, data/e3_speed.csv
+(figures come from replot_all.py only)
+"""
+import os
+import numpy as np
+from semantic_mac import (affinity_matrix, matched_filter, demux_sr, demux_sc,
+                          demux_lmmse, demux_dr, sample_latents_isotropic,
+                          mobility_trajectories, AffinityTracker,
+                          pilot_affinity_obs, metrics,
+                          oma_observe, demux_noma_genie)
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIG = os.path.join(HERE, "..", "fig")
+DATA = os.path.join(HERE, "..", "data")
+os.makedirs(FIG, exist_ok=True)
+os.makedirs(DATA, exist_ok=True)
+
+U, D, DC = 4, 64, 16
+BATCH = 320
+SNR_DB = 12
+RHO = 10 ** (SNR_DB / 10)
+T = 300
+K_PILOT = 5          # pilot every K slots
+N_PILOT = 64         # pilot embeddings per user per pilot slot
+LAM = 0.3
+METHODS = ["DR-genie", "DR-tracked", "DR-static", "SR", "SC", "LMMSE",
+           "OMA", "NOMA"]
+MOB = dict(box=50.0, r_scene=32.0, a_max=0.95)
+
+
+def run_trace(a_t, rng, collect_ts=False):
+    Vc = np.eye(D)[:, :DC]
+    a_bar = a_t.mean(axis=0)
+    tracker = AffinityTracker(U, lam=LAM, a_init=float(a_bar.mean()))
+    sers = {m: [] for m in METHODS}
+    coss = {m: [] for m in METHODS}
+    a_hat_log = []
+    for t in range(a_t.shape[0]):
+        a = a_t[t]
+        B = affinity_matrix(a)
+        z = sample_latents_isotropic(BATCH, U, D, DC, a, rng)
+        tilde, h = matched_filter(z, B, RHO, rng)
+
+        if t % K_PILOT == 0:
+            zp = sample_latents_isotropic(N_PILOT, U, D, DC, a, rng)
+            hp = np.clip(np.abs((rng.standard_normal(U) +
+                                 1j * rng.standard_normal(U)) / np.sqrt(2)),
+                         0.2, None)
+            tracker.update(pilot_affinity_obs(zp, hp, RHO, rng))
+        a_hat = np.clip(tracker.a, 0.02, 0.95)
+
+        out = {}
+        out["DR-genie"] = demux_dr(tilde, B, h, RHO, a, Vc)
+        out["DR-tracked"] = demux_dr(tilde, affinity_matrix(a_hat), h, RHO,
+                                     a_hat, Vc)
+        out["DR-static"] = demux_dr(tilde, affinity_matrix(a_bar), h, RHO,
+                                    a_bar, Vc)
+        out["SR"] = demux_sr(tilde, B, h)
+        out["SC"] = demux_sc(tilde, h)
+        out["LMMSE"], _ = demux_lmmse(tilde, B, h, RHO)
+        out["OMA"] = oma_observe(z, h, RHO, rng)
+        out["NOMA"] = demux_noma_genie(z, h, RHO, rng)
+
+        a_hat_log.append(a_hat)
+        for m in METHODS:
+            c, _, s = metrics(out[m], z)
+            sers[m].append(s)
+            coss[m].append(c)
+    res = {m: (float(np.mean(coss[m])), float(np.mean(sers[m])))
+           for m in METHODS}
+    if collect_ts:
+        return res, sers, np.array(a_hat_log)
+    return res
+
+
+def drive_through_profile(T, peaks=(80, 110, 140, 170), width=45.0,
+                          a_lo=0.05, a_hi=0.9):
+    """Scene pass-by: each user approaches the shared scene, dwells, leaves."""
+    t = np.arange(T)[:, None]
+    pk = np.asarray(peaks)[None, :]
+    return a_lo + (a_hi - a_lo) * np.exp(-(t - pk) ** 2 / (2 * width ** 2))
+
+
+def main():
+    # --- time-series: scene pass-by, averaged over REPS_TS runs -------------
+    a_t = drive_through_profile(T)
+    REPS_TS = 5
+    sers_acc = None
+    means_acc = {m: [] for m in METHODS}
+    for rep_i in range(REPS_TS):
+        rng = np.random.default_rng(3 + rep_i)
+        res_i, sers_i, a_hat_i = run_trace(a_t, rng, collect_ts=True)
+        if rep_i == 0:
+            a_hat_log = a_hat_i
+        if sers_acc is None:
+            sers_acc = {m: np.array(sers_i[m], float) for m in METHODS}
+        else:
+            for m in METHODS:
+                sers_acc[m] += np.array(sers_i[m], float)
+        for m in METHODS:
+            means_acc[m].append(res_i[m])
+        print(f"  ts rep {rep_i+1}/{REPS_TS} done")
+    sers = {m: (sers_acc[m] / REPS_TS).tolist() for m in METHODS}
+    res = {m: (float(np.mean([x[0] for x in means_acc[m]])),
+               float(np.mean([x[1] for x in means_acc[m]])))
+           for m in METHODS}
+    print("time-series means:", {m: f"cos={v[0]:.3f},ser={v[1]:.3f}"
+                                 for m, v in res.items()})
+    with open(os.path.join(DATA, "e3_timeseries.csv"), "w") as f:
+        f.write("t," + ",".join(f"a{u}" for u in range(U)) + ","
+                + ",".join(f"ahat{u}" for u in range(U)) + ","
+                + ",".join(f"{m}_ser" for m in METHODS) + "\n")
+        for t in range(T):
+            f.write(f"{t}," + ",".join(f"{a_t[t,u]:.4f}" for u in range(U))
+                    + "," + ",".join(f"{a_hat_log[t,u]:.4f}" for u in range(U))
+                    + "," + ",".join(f"{sers[m][t]:.4f}" for m in METHODS) + "\n")
+
+    # --- speed sweep (averaged over trajectory seeds) -----------------------
+    speeds = [0.5, 1.0, 2.0, 4.0, 8.0]
+    reps = 8
+    rows = []
+    for si, sp in enumerate(speeds):
+        acc = {m: [] for m in METHODS}
+        for rep in range(reps):
+            # disjoint seed blocks per speed point (no seed reuse across
+            # speeds)
+            rng_s = np.random.default_rng(1000 + 100 * si + rep)
+            a_tr = mobility_trajectories(U, T, sp, rng_s, **MOB)
+            r = run_trace(a_tr, rng_s)
+            for m in METHODS:
+                acc[m].append(r[m])
+        rows.append({m: (float(np.mean([x[0] for x in acc[m]])),
+                         float(np.mean([x[1] for x in acc[m]])))
+                     for m in METHODS})
+        print(f"speed={sp} " + " ".join(f"{m}:ser={rows[-1][m][1]:.3f}"
+                                        for m in METHODS))
+    with open(os.path.join(DATA, "e3_speed.csv"), "w") as f:
+        f.write("speed," + ",".join(f"{m}_cos,{m}_ser" for m in METHODS) + "\n")
+        for sp, r in zip(speeds, rows):
+            f.write(f"{sp}," + ",".join(f"{r[m][0]},{r[m][1]}"
+                                        for m in METHODS) + "\n")
+
+    # figures are produced only by the canonical replot_all.py (uniform
+    # geometry); experiment scripts write CSVs exclusively.
+    print("E3 done. Run replot_all.py to regenerate the figures.")
+
+
+if __name__ == "__main__":
+    main()

code/exp4_mismatch.py

@@ -0,0 +1,54 @@
+"""E4: robustness of the decomposition receiver to affinity estimation error.
+
+DR runs with a_hat = a + delta; theory predicts O(delta^2) degradation.
+
+Outputs: data/e4_mismatch.csv
+(figures come from replot_all.py only)
+"""
+import math
+import os
+import numpy as np
+from semantic_mac import (affinity_matrix, matched_filter, demux_dr,
+                          sample_latents_isotropic, metrics)
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIG = os.path.join(HERE, "..", "fig")
+DATA = os.path.join(HERE, "..", "data")
+os.makedirs(FIG, exist_ok=True)
+os.makedirs(DATA, exist_ok=True)
+
+U, D, DC = 4, 64, 16
+BATCH = 4000
+BETA = 0.5
+
+
+def main():
+    rng = np.random.default_rng(11)
+    a = math.sqrt(BETA) * np.ones(U)
+    B = affinity_matrix(a)
+    Vc = np.eye(D)[:, :DC]
+    deltas = np.arange(-0.20, 0.201, 0.04)
+    rows = []
+    for snr_db in (5, 10, 15):
+        rho = 10 ** (snr_db / 10)
+        z = sample_latents_isotropic(BATCH, U, D, DC, a, rng)
+        tilde, h = matched_filter(z, B, rho, rng)
+        for d0 in deltas:
+            a_hat = np.clip(a + d0, 0.02, 0.98)
+            B_hat = affinity_matrix(a_hat)
+            cos, _, ser = metrics(
+                demux_dr(tilde, B_hat, h, rho, a_hat, Vc), z)
+            rows.append((snr_db, float(d0), cos, ser))
+            print(f"snr={snr_db} delta={d0:+.2f} cos={cos:.4f} ser={ser:.4f}")
+    with open(os.path.join(DATA, "e4_mismatch.csv"), "w") as f:
+        f.write("snr,delta,cos,ser\n")
+        for r in rows:
+            f.write(",".join(str(x) for x in r) + "\n")
+
+    # figures are produced only by the canonical replot_all.py (uniform
+    # geometry); experiment scripts write CSVs exclusively.
+    print("E4 done. Run replot_all.py to regenerate the figures.")
+
+
+if __name__ == "__main__":
+    main()

code/exp5_learned.py

@@ -0,0 +1,125 @@
+"""E5: comparison with a trained user-wise attention receiver.
+
+A learned receiver representative of the end-to-end line (per-user query
+attention over the matched-filter outputs, residual skip, unit
+normalization) is trained at the operating SNR over uniformly random
+affinities, then compared against the closed-form LMMSE and DR receivers
+across the affinity sweep. The learned receiver receives no affinity side
+information and must infer the coupling from data, which is the standard
+setting of the learned line.
+
+Outputs: data/e5_learned.csv, data/e5_train_log.csv
+(figures come from replot_all.py only)
+"""
+import math
+import os
+import numpy as np
+import torch
+
+from semantic_mac import (affinity_matrix, matched_filter,
+                          sample_latents_isotropic, demux_lmmse, demux_dr,
+                          demux_sr, demux_sc, metrics)
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIG = os.path.join(HERE, "..", "fig")
+DATA = os.path.join(HERE, "..", "data")
+
+U, D, DC = 4, 64, 16
+SNR_DB = 10
+RHO = 10 ** (SNR_DB / 10)
+STEPS = 3000
+BATCH = 64
+
+
+class UserWiseAttention(torch.nn.Module):
+    """Per-user query attention over the U matched-filter outputs."""
+
+    def __init__(self, U, d, dk=16, heads=4):
+        super().__init__()
+        self.U, self.d, self.dk, self.H = U, d, dk, heads
+        self.WK = torch.nn.Linear(d, dk * heads, bias=False)
+        self.WV = torch.nn.Linear(d, dk * heads, bias=False)
+        self.WO = torch.nn.Linear(dk * heads, d, bias=False)
+        self.q = torch.nn.Parameter(torch.randn(U, heads, dk) * 0.1)
+        self.log_eta = torch.nn.Parameter(torch.zeros(()))
+
+    def forward(self, tilde):
+        B, Uu, d = tilde.shape
+        K = self.WK(tilde).view(B, Uu, self.H, self.dk)
+        V = self.WV(tilde).view(B, Uu, self.H, self.dk)
+        sc = torch.einsum('uhk,bihk->buih', self.q, K) / math.sqrt(self.dk)
+        alpha = torch.softmax(torch.exp(self.log_eta) * sc, dim=2)
+        ctx = torch.einsum('buih,bihk->buhk', alpha, V).reshape(B, Uu, -1)
+        out = self.WO(ctx) + tilde
+        return out / (out.norm(dim=2, keepdim=True) + 1e-12)
+
+
+def gen_batch(rng, batch, beta):
+    a = math.sqrt(beta) * np.ones(U)
+    B = affinity_matrix(a)
+    z = sample_latents_isotropic(batch, U, D, DC, a, rng)
+    tilde, h = matched_filter(z, B, RHO, rng)
+    return z, tilde, h, a, B
+
+
+def main():
+    torch.manual_seed(0)
+    rng = np.random.default_rng(21)
+    net = UserWiseAttention(U, D)
+    n_par = sum(p.numel() for p in net.parameters())
+    print(f"learned receiver parameters: {n_par}")
+    opt = torch.optim.Adam(net.parameters(), lr=1e-3)
+    train_log = []
+    for it in range(STEPS):
+        beta = float(rng.uniform(0.05, 0.9))
+        z, tilde, h, a, B = gen_batch(rng, BATCH, beta)
+        zt = torch.tensor(z, dtype=torch.float32)
+        tt = torch.tensor(tilde, dtype=torch.float32)
+        out = net(tt)
+        loss = (1.0 - (out * zt).sum(-1)).mean()
+        opt.zero_grad()
+        loss.backward()
+        opt.step()
+        if (it + 1) % 50 == 0:
+            train_log.append((it + 1, float(loss.item())))
+        if (it + 1) % 500 == 0:
+            print(f"  step {it+1}: loss={loss.item():.4f}")
+    # convergence evidence for the fixed training budget
+    with open(os.path.join(DATA, "e5_train_log.csv"), "w") as f:
+        f.write("step,loss\n")
+        for st, lo in train_log:
+            f.write(f"{st},{lo}\n")
+
+    # evaluation across the affinity sweep
+    betas = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+    Vc = np.eye(D)[:, :DC]
+    rows = []
+    net.eval()
+    rng_e = np.random.default_rng(500)
+    for beta in betas:
+        z, tilde, h, a, B = gen_batch(rng_e, 4000, beta)
+        with torch.no_grad():
+            out_l = net(torch.tensor(tilde, dtype=torch.float32)).numpy()
+        r = {}
+        r["Learned"] = metrics(out_l.astype(np.float64), z)
+        lm, _ = demux_lmmse(tilde, B, h, RHO)
+        r["LMMSE"] = metrics(lm, z)
+        r["DR"] = metrics(demux_dr(tilde, B, h, RHO, a, Vc), z)
+        rows.append(r)
+        print(f"beta={beta:.2f} " + " ".join(
+            f"{k}:cos={v[0]:.3f},ser={v[2]:.3f}" for k, v in r.items()))
+    with open(os.path.join(DATA, "e5_learned.csv"), "w") as f:
+        keys = ["Learned", "LMMSE", "DR"]
+        f.write("beta," + ",".join(f"{k}_cos,{k}_nmse,{k}_ser" for k in keys)
+                + "\n")
+        for b, r in zip(betas, rows):
+            f.write(f"{b}," + ",".join(
+                f"{r[k][0]},{r[k][1]},{r[k][2]}" for k in keys) + "\n")
+
+    # figures are produced only by the canonical replot_all.py (uniform
+    # geometry); experiment scripts write CSVs exclusively.
+    print("E5 done. Run replot_all.py to regenerate the figures.")
+
+
+if __name__ == "__main__":
+    main()

code/lmmse_verify.py

@@ -0,0 +1,321 @@
+"""
+Verify Proposition-candidate 1 for the 8th (TMC) paper:
+
+  The B-aware LMMSE receiver
+      W*(B,H,sigma^2) = C_x Gamma^T (Gamma C_x Gamma^T + C_n)^{-1}
+  (i)   -> Gamma^{-1} (= SR / AA-EDMA demux)      as rho -> inf
+  (ii)  -> per-user Wiener (no cross-processing)  as beta -> 0
+  (iii) -> coherent combining (SC / MRC)          as beta -> 1
+  (iv)  dominates SR and SC at every (beta, rho); strict gap at intermediate beta.
+
+Also simulates an oracle decomposition receiver (ODR) that knows the
+shared/private subspace split — the ceiling motivating structured
+embedding learning.
+
+Self-contained: model/conventions come from the project's own
+semantic_mac.py (matched filter, affinity, metrics), so this script
+verifies the same library that produces the paper results.
+"""
+from __future__ import annotations
+import math
+import os
+import numpy as np
+
+from semantic_mac import affinity_matrix, matched_filter, metrics
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+OUT = os.path.join(HERE, "..", "fig")
+os.makedirs(OUT, exist_ok=True)
+
+TAU = 0.45  # SER threshold, as in CL paper
+
+
+# ----------------------------------------------------------------------
+#  Structured embedding generator with a FIXED shared subspace
+#  (needed for the ODR ceiling; statistically identical Gram to uwca_core's
+#   sample_embeddings: E[<e_u,e_v>] = a_u a_v)
+# ----------------------------------------------------------------------
+def sample_embeddings_structured(batch, U, d, d_c, a, rng):
+    """Shared content c lives in the FIRST d_c coordinates (unit norm there);
+    private p_u are mutually orthogonal unit vectors in the remaining d-d_c.
+      e_u = a_u * [c; 0] + sqrt(1-a_u^2) * [0; p_u]
+    Returns e (batch,U,d), c (batch,d_c), p (batch,U,d-d_c)."""
+    a = np.broadcast_to(np.asarray(a, float), (U,))
+    e = np.zeros((batch, U, d))
+    c_all = np.zeros((batch, d_c))
+    p_all = np.zeros((batch, U, d - d_c))
+    for b in range(batch):
+        c = rng.standard_normal(d_c)
+        c /= np.linalg.norm(c)
+        G = rng.standard_normal((d - d_c, U))
+        Q, _ = np.linalg.qr(G)                      # orthonormal private dirs
+        c_all[b] = c
+        for u in range(U):
+            p_all[b, u] = Q[:, u]
+            e[b, u, :d_c] = a[u] * c
+            e[b, u, d_c:] = math.sqrt(1.0 - a[u] ** 2) * Q[:, u]
+    return e, c_all, p_all
+
+
+# ----------------------------------------------------------------------
+#  Receivers (all consume the matched-filter outputs `tilde`)
+# ----------------------------------------------------------------------
+def lmmse_matrices(B, h, sigma2, d):
+    """Return (W, Eerr) for one sample: W (U,U), Eerr (U,U) per-dim error cov."""
+    H = np.diag(h)
+    Hi = np.diag(1.0 / h)
+    Gamma = Hi @ B @ H
+    Cx = B / d
+    Cn = sigma2 * (Hi @ B @ Hi)
+    S = Gamma @ Cx @ Gamma.T + Cn
+    W = Cx @ Gamma.T @ np.linalg.solve(S.T, np.eye(len(h))).T  # Cx Γ^T S^{-1}
+    Eerr = Cx - W @ Gamma @ Cx
+    return W, Eerr
+
+
+def demux_lmmse(tilde, B, h, rho):
+    """B-aware LMMSE. Returns (e_hat_raw, closed-form per-user MSE avg over batch)."""
+    batch, U, d = tilde.shape
+    sigma2 = 1.0 / rho
+    out = np.empty_like(tilde)
+    mse_cf = np.zeros(U)
+    for b in range(batch):
+        W, Eerr = lmmse_matrices(B, h[b], sigma2, d)
+        out[b] = W @ tilde[b]
+        mse_cf += d * np.diag(Eerr)
+    return out, mse_cf / batch
+
+
+def demux_sr_raw(tilde, B, h):
+    """SR (AA-EDMA) without normalization, for raw-MSE comparison."""
+    batch, U, d = tilde.shape
+    out = np.empty_like(tilde)
+    for b in range(batch):
+        H = np.diag(h[b])
+        Gamma = np.linalg.inv(H) @ B @ H
+        out[b] = np.linalg.solve(Gamma, tilde[b])
+    return out
+
+
+def sr_mse_closed(B, h, rho, d):
+    """d * sigma^2 [B^{-1}]_uu / h_u^2, averaged over batch of h."""
+    Binv_uu = np.diag(np.linalg.inv(B))
+    return (d / rho) * (Binv_uu[None, :] / h ** 2).mean(axis=0)
+
+
+def demux_sc_mrc(tilde, h):
+    """Pure combining (SC endpoint): every user gets the h^2-weighted sum of
+    all matched-filter outputs (MRC under the fully-shared hypothesis)."""
+    w = h ** 2                                       # (batch,U)
+    w = w / w.sum(axis=1, keepdims=True)
+    comb = np.einsum('bu,bud->bd', w, tilde)         # (batch,d)
+    return np.repeat(comb[:, None, :], tilde.shape[1], axis=1)
+
+
+def demux_odr(tilde, B, h, rho, a, d_c):
+    """Oracle decomposition receiver: knows the fixed shared subspace
+    (first d_c coords), a and h.
+      shared:  BLUE-combine the U looks at c, then Wiener shrink
+      private: SR (Gamma^{-1}) on the complement, then Wiener shrink
+      recombine e_hat_u = a_u c_hat + g_hat_u."""
+    batch, U, d = tilde.shape
+    sigma2 = 1.0 / rho
+    a = np.broadcast_to(np.asarray(a, float), (U,))
+    out = np.empty_like(tilde)
+    for b in range(batch):
+        hb = h[b]
+        Hi = np.diag(1.0 / hb)
+        Gamma = np.diag(1.0 / hb) @ B @ np.diag(hb)
+        Cn = sigma2 * (Hi @ B @ Hi)                  # per-dim MF noise cov
+        # ---- shared part: z_u = gamma_u * c + n_u on first d_c dims
+        gamma = np.array([
+            a[u] + sum(B[u, v] * a[v] * hb[v] / hb[u] for v in range(U) if v != u)
+            for u in range(U)
+        ])
+        Z = tilde[b, :, :d_c]                        # (U, d_c)
+        Cn_inv = np.linalg.inv(Cn)
+        denom = gamma @ Cn_inv @ gamma
+        if denom > 1e-12:                            # beta=0 -> no shared part
+            c_hat = (gamma @ Cn_inv @ Z) / denom     # BLUE, (d_c,)
+            # Wiener shrink: per-dim signal var 1/d_c, BLUE error var 1/denom
+            shrink_c = (1.0 / d_c) / (1.0 / d_c + 1.0 / denom)
+            c_hat = shrink_c * c_hat
+        else:
+            c_hat = np.zeros(d_c)
+        # ---- private part: SR on the complement
+        Gp = np.linalg.solve(Gamma, tilde[b, :, d_c:])   # (U, d-d_c) est of g_u
+        Binv = np.linalg.inv(B)
+        for u in range(U):
+            sig_p = 1.0 - a[u] ** 2                       # ||g_u||^2
+            err_p = (d - d_c) * sigma2 * Binv[u, u] / hb[u] ** 2
+            shrink_p = sig_p / (sig_p + err_p)
+            out[b, u, :d_c] = a[u] * c_hat
+            out[b, u, d_c:] = shrink_p * Gp[u]
+    return out
+
+
+# ----------------------------------------------------------------------
+#  Evaluation helpers
+# ----------------------------------------------------------------------
+def eval_all(e, tilde, h, B, rho, a, d_c, with_odr=True):
+    """Return dict name -> (nmse_raw, cos, ser) plus closed forms."""
+    d = e.shape[2]
+    res = {}
+
+    def add(name, e_hat_raw):
+        nmse = ((e_hat_raw - e) ** 2).sum(-1).mean()
+        e_n = e_hat_raw / (np.linalg.norm(e_hat_raw, axis=2, keepdims=True) + 1e-12)
+        cos, _, ser = metrics(e_n, e, tau=TAU)
+        res[name] = dict(nmse=float(nmse), cos=cos, ser=ser)
+
+    add("MF (TIN)", tilde.copy())
+    add("SR (AA-EDMA)", demux_sr_raw(tilde, B, h))
+    add("SC (MRC)", demux_sc_mrc(tilde, h))
+    lm, mse_cf = demux_lmmse(tilde, B, h, rho)
+    add("LMMSE (proposed)", lm)
+    res["LMMSE (proposed)"]["nmse_cf"] = float(mse_cf.mean())
+    res["SR (AA-EDMA)"]["nmse_cf"] = float(sr_mse_closed(B, h, rho, d).mean())
+    if with_odr:
+        add("ODR (oracle)", demux_odr(tilde, B, h, rho, a, d_c))
+    return res
+
+
+def run_sweep(betas, rho, U=4, d=64, d_c=16, batch=3000, seed=0):
+    rng = np.random.default_rng(seed)
+    rows = []
+    for beta in betas:
+        a = math.sqrt(beta) * np.ones(U)
+        B = affinity_matrix(a)
+        e, _, _ = sample_embeddings_structured(batch, U, d, d_c, a, rng)
+        tilde, h = matched_filter(e, B, rho, rng, fading=True)
+        res = eval_all(e, tilde, h, B, rho, a, d_c)
+        rows.append((beta, res))
+        lm, sr = res["LMMSE (proposed)"], res["SR (AA-EDMA)"]
+        print(f"beta={beta:4.2f} | LMMSE nmse {lm['nmse']:.4f} (cf {lm['nmse_cf']:.4f}) "
+              f"cos {lm['cos']:.3f} | SR nmse {sr['nmse']:.4f} (cf {sr['nmse_cf']:.4f}) "
+              f"cos {sr['cos']:.3f} | SC cos {res['SC (MRC)']['cos']:.3f} "
+              f"| ODR cos {res['ODR (oracle)']['cos']:.3f}")
+    return rows
+
+
+def run_snr_sweep(beta, rhos_db, U=4, d=64, d_c=16, batch=3000, seed=1):
+    rng = np.random.default_rng(seed)
+    a = math.sqrt(beta) * np.ones(U)
+    B = affinity_matrix(a)
+    rows = []
+    for rdb in rhos_db:
+        rho = 10 ** (rdb / 10)
+        e, _, _ = sample_embeddings_structured(batch, U, d, d_c, a, rng)
+        tilde, h = matched_filter(e, B, rho, rng, fading=True)
+        res = eval_all(e, tilde, h, B, rho, a, d_c)
+        rows.append((rdb, res))
+        print(f"SNR={rdb:3d} dB | " + " | ".join(
+            f"{k.split(' ')[0]} cos {v['cos']:.3f} ser {v['ser']:.3f}"
+            for k, v in res.items()))
+    return rows
+
+
+# ----------------------------------------------------------------------
+#  Endpoint checks (Proposition 1 (i)-(iii))
+# ----------------------------------------------------------------------
+def endpoint_checks(U=4, d=64, seed=2):
+    rng = np.random.default_rng(seed)
+    print("\n=== Endpoint checks ===")
+    # (i) high SNR: W* -> Gamma^{-1}
+    beta = 0.4
+    a = math.sqrt(beta) * np.ones(U)
+    B = affinity_matrix(a)
+    h = np.clip(np.abs((rng.standard_normal(U) + 1j * rng.standard_normal(U)) / math.sqrt(2)), 0.2, None)
+    for rdb in (10, 40, 80):
+        W, _ = lmmse_matrices(B, h, 10 ** (-rdb / 10), d)
+        Ginv = np.linalg.inv(np.diag(1 / h) @ B @ np.diag(h))
+        rel = np.linalg.norm(W - Ginv) / np.linalg.norm(Ginv)
+        print(f"(i)   rho={rdb:2d} dB : ||W*-Gamma^-1||_F/||Gamma^-1||_F = {rel:.2e}")
+    # (ii) beta=0: off-diagonal of W* vanishes, diagonal = Wiener
+    W0, _ = lmmse_matrices(np.eye(U), h, 0.1, d)
+    off = np.abs(W0 - np.diag(np.diag(W0))).max()
+    wiener = h ** 2 / (h ** 2 + d * 0.1)
+    diag_err = np.abs(np.diag(W0) - wiener).max()
+    print(f"(ii)  beta=0    : max|offdiag W*| = {off:.2e}, max|diag - Wiener| = {diag_err:.2e}")
+    # (iii) beta->1: W* row ~ rank-1 combining; compare to SC weights h^2-normalized
+    a1 = math.sqrt(0.999) * np.ones(U)
+    B1 = affinity_matrix(a1)
+    W1, _ = lmmse_matrices(B1, h, 0.1, d)
+    r = W1[0] * h  # undo the h_v/h_u structure: effective combining weights on h_v e_v looks
+    r = np.abs(r) / np.abs(r).sum()
+    mrc = h ** 2 / (h ** 2).sum()
+    print(f"(iii) beta=.999 : normalized row-0 weights {np.round(r,3)} vs MRC {np.round(mrc,3)}")
+
+
+# ----------------------------------------------------------------------
+#  Figures
+# ----------------------------------------------------------------------
+def plot_all(rows_beta, rows_snr, rho_db, beta_mid):
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    names = ["MF (TIN)", "SR (AA-EDMA)", "SC (MRC)", "LMMSE (proposed)", "ODR (oracle)"]
+    styles = {"MF (TIN)": ("0.6", ":", "v"),
+              "SR (AA-EDMA)": ("tab:red", "--", "s"),
+              "SC (MRC)": ("tab:green", "-.", "^"),
+              "LMMSE (proposed)": ("tab:blue", "-", "o"),
+              "ODR (oracle)": ("k", ":", "d")}
+
+    betas = [b for b, _ in rows_beta]
+
+    # Fig 1: NMSE vs beta + closed-form overlays
+    fig, ax = plt.subplots(figsize=(6.4, 4.6))
+    for n in names:
+        c, ls, mk = styles[n]
+        ax.semilogy(betas, [r[n]["nmse"] for _, r in rows_beta], ls, color=c, marker=mk,
+                    ms=4, label=n)
+    ax.semilogy(betas, [r["LMMSE (proposed)"]["nmse_cf"] for _, r in rows_beta],
+                'x', color="tab:blue", ms=9, mew=2, label="LMMSE closed form")
+    ax.semilogy(betas, [r["SR (AA-EDMA)"]["nmse_cf"] for _, r in rows_beta],
+                '+', color="tab:red", ms=10, mew=2, label="SR closed form")
+    ax.set_xlabel(r"semantic affinity  $\beta$")
+    ax.set_ylabel("NMSE")
+    ax.set_title(f"NMSE vs affinity (U=4, d=64, SNR={rho_db} dB)")
+    ax.grid(True, which="both", alpha=0.3)
+    ax.legend(fontsize=8)
+    fig.tight_layout()
+    fig.savefig(os.path.join(OUT, "fig1_nmse_vs_beta.png"), dpi=160)
+
+    # Fig 2: cosine + SER vs beta
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4.4))
+    for n in names:
+        c, ls, mk = styles[n]
+        axes[0].plot(betas, [r[n]["cos"] for _, r in rows_beta], ls, color=c, marker=mk, ms=4, label=n)
+        axes[1].semilogy(betas, [max(r[n]["ser"], 1e-4) for _, r in rows_beta], ls, color=c, marker=mk, ms=4, label=n)
+    axes[0].set_xlabel(r"$\beta$"); axes[0].set_ylabel("mean cosine"); axes[0].grid(alpha=0.3)
+    axes[1].set_xlabel(r"$\beta$"); axes[1].set_ylabel(f"SER (tau={TAU})"); axes[1].grid(True, which="both", alpha=0.3)
+    axes[0].legend(fontsize=8)
+    fig.suptitle(f"Cosine recovery / SER vs affinity (U=4, d=64, SNR={rho_db} dB)")
+    fig.tight_layout()
+    fig.savefig(os.path.join(OUT, "fig2_cos_ser_vs_beta.png"), dpi=160)
+
+    # Fig 3: SNR sweep at intermediate beta
+    rhos = [r for r, _ in rows_snr]
+    fig, ax = plt.subplots(figsize=(6.4, 4.6))
+    for n in names:
+        c, ls, mk = styles[n]
+        ax.semilogy(rhos, [max(r[n]["ser"], 1e-4) for _, r in rows_snr], ls, color=c, marker=mk, ms=4, label=n)
+    ax.set_xlabel("SNR (dB)"); ax.set_ylabel(f"SER (tau={TAU})")
+    ax.set_title(f"SER vs SNR at intermediate affinity beta={beta_mid}")
+    ax.grid(True, which="both", alpha=0.3); ax.legend(fontsize=8)
+    fig.tight_layout()
+    fig.savefig(os.path.join(OUT, "fig3_ser_vs_snr.png"), dpi=160)
+    print(f"\nFigures saved to {OUT}")
+
+
+if __name__ == "__main__":
+    RHO_DB = 10
+    BETAS = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99]
+    print(f"=== beta sweep @ {RHO_DB} dB ===")
+    rows_beta = run_sweep(BETAS, 10 ** (RHO_DB / 10))
+    BETA_MID = 0.4
+    print(f"\n=== SNR sweep @ beta={BETA_MID} ===")
+    rows_snr = run_snr_sweep(BETA_MID, list(range(0, 21, 4)))
+    endpoint_checks()
+    plot_all(rows_beta, rows_snr, RHO_DB, BETA_MID)

code/replot_all.py

@@ -0,0 +1,268 @@
+"""Regenerate all paper figures from the CSVs in ../data with
+publication-quality layout (no legend/curve overlap, consistent styling,
+conventional-scheme baselines included).
+
+This is the canonical figure generator; experiment scripts write the CSVs.
+"""
+import csv
+import os
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIG = os.path.join(HERE, "..", "fig")
+DATA = os.path.join(HERE, "..", "data")
+
+plt.rcParams.update({
+    "font.size": 8.5,
+    "axes.labelsize": 8.5,
+    "legend.fontsize": 6.5,
+    "xtick.labelsize": 8,
+    "ytick.labelsize": 8,
+    "lines.linewidth": 1.15,
+    "lines.markersize": 3.2,
+})
+
+
+FIGW, FIGH = 2.9, 2.25
+AXRECT = [0.185, 0.18, 0.77, 0.7444]   # exact 8:6 axes box, identical everywhere
+
+
+def new_fig():
+    """Canvas and axes rectangle identical for every figure, so every plot
+    box renders at exactly the same size in the paper."""
+    fig = plt.figure(figsize=(FIGW, FIGH))
+    ax = fig.add_axes(AXRECT)
+    return fig, ax
+
+
+def load(name):
+    with open(os.path.join(DATA, name)) as f:
+        return list(csv.DictReader(f))
+
+
+def savefig(fig, name):
+    fig.savefig(os.path.join(FIG, name))
+    print("saved", name)
+
+
+S = {"OMA": ("0.45", ":", "v"), "NOMA": ("tab:brown", ":", "P"),
+     "SR": ("tab:red", "--", "s"), "SC": ("tab:green", "-.", "^"),
+     "LMMSE": ("tab:blue", "-", "o"), "DR": ("k", "-", "d")}
+LBL = {"OMA": "OMA", "NOMA": "NOMA-SIC", "SR": "SR",
+       "SC": "SC", "LMMSE": "LMMSE", "DR": "Proposed DR"}
+ORDER = ["OMA", "NOMA", "SR", "SC", "LMMSE", "DR"]
+
+# ---------------------------------------------------------------- E1 beta
+rows = load("e1_beta.csv")
+betas = [float(r["beta"]) for r in rows]
+
+fig, ax = new_fig()
+for n in ORDER:
+    c, ls, mk = S[n]
+    ax.semilogy(betas, [float(r[f"{n}_nmse"]) for r in rows], ls, color=c,
+                marker=mk, label=LBL[n])
+ax.semilogy(betas, [float(r["LMMSE_cf"]) for r in rows], 'x',
+            color="tab:blue", ms=6.5, mew=1.5, ls="none",
+            label="LMMSE closed form")
+ax.semilogy(betas, [float(r["SR_cf"]) for r in rows], '+', color="tab:red",
+            ms=7.5, mew=1.5, ls="none", label="SR closed form")
+ax.set_xlabel(r"affinity $\beta$")
+ax.set_ylabel("NMSE")
+ax.set_ylim(6e-2, 8e6)
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="upper left", ncol=2, columnspacing=0.7, handletextpad=0.4,
+          labelspacing=0.3)
+savefig(fig, "fig_e1_beta_nmse.pdf")
+
+fig, ax = new_fig()
+for n in ORDER:
+    c, ls, mk = S[n]
+    ax.plot(betas, [float(r[f"{n}_cos"]) for r in rows], ls, color=c,
+            marker=mk, label=LBL[n])
+ax.set_xlabel(r"affinity $\beta$")
+ax.set_ylabel("mean cosine recovery")
+ax.set_ylim(0.0, 1.05)
+ax.grid(alpha=0.3)
+ax.legend(loc="upper left", ncol=2, columnspacing=0.7, handletextpad=0.4,
+          labelspacing=0.3)
+savefig(fig, "fig_e1_beta_cos.pdf")
+
+# ---------------------------------------------------------------- E1 snr
+rows = load("e1_snr.csv")
+snrs = [float(r["snr"]) for r in rows]
+fig, ax = new_fig()
+for n in ORDER:
+    c, ls, mk = S[n]
+    ax.semilogy(snrs, [max(float(r[f"{n}_ser"]), 1e-4) for r in rows], ls,
+                color=c, marker=mk, label=LBL[n])
+ax.set_xlabel("per-user SNR (dB)")
+ax.set_ylabel("semantic error rate")
+ax.set_ylim(8e-4, 2.5)
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="lower left", ncol=1, fontsize=6.1, handletextpad=0.4,
+          labelspacing=0.25, borderpad=0.3)
+savefig(fig, "fig_e1_snr.pdf")
+
+# ---------------------------------------------- E2 spectrum (multi-curve)
+rows_s = load("e2_spectrum_multi.csv")
+fig, ax = new_fig()
+for n_cal, c, ls in ((100, "tab:orange", "-."), (400, "tab:green", "--"),
+                     (1600, "tab:blue", "-")):
+    pts = [(int(r["idx"]), float(r["eig"])) for r in rows_s
+           if int(r["N"]) == n_cal]
+    ax.semilogy([p[0] for p in pts],
+                np.maximum([p[1] for p in pts], 1e-12), ls, color=c,
+                lw=1.15, label=f"$N{{=}}{n_cal}$")
+ax.axvline(128, color="k", ls=":", lw=0.9)
+ax.annotate(r"$d_c=128$", xy=(128, 1e-6), xytext=(150, 3e-7), fontsize=7.5,
+            arrowprops=dict(arrowstyle="-", lw=0.6, color="0.3"))
+ax.set_xlabel("eigenvalue index")
+ax.set_ylabel(r"eigenvalue of $\hat{\mathbf{\Sigma}}$")
+ax.set_ylim(1e-8, 3e-1)
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="upper right", labelspacing=0.3)
+savefig(fig, "fig_e2_spectrum.pdf")
+
+# ---------------------------------------------- E2 subspace (multi-curve)
+rows_n = load("e2_subspace_multi.csv")
+fig, ax = new_fig()
+for Um, c, mk, ls in ((2, "tab:orange", "s", "-."),
+                      (4, "tab:blue", "o", "-"),
+                      (8, "tab:green", "^", "--")):
+    pts = [(int(r["N"]), float(r["err"])) for r in rows_n
+           if int(r["U"]) == Um]
+    ax.loglog([p[0] for p in pts], [p[1] for p in pts], ls, color=c,
+              marker=mk, label=f"$U{{=}}{Um}$")
+ax.set_xlabel("paired calibration samples $N$")
+ax.set_ylabel("subspace recovery error")
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="upper right", labelspacing=0.3)
+savefig(fig, "fig_e2_subspace.pdf")
+
+# ---------------------------------------------------------------- E2 ladder
+rows = load("e2_ladder.csv")
+snrs = [float(r["snr"]) for r in rows]
+S2 = {"OMA": ("0.45", ":", "v", "OMA"),
+      "NOMA": ("tab:brown", ":", "P", "NOMA-SIC"),
+      "LMMSE": ("tab:blue", "-", "o", "LMMSE"),
+      "DR-spec": ("tab:orange", "--", "s", "DR + spectral"),
+      "DR-adapt": ("tab:purple", "-", "^", "DR + adapter"),
+      "DR-oracle": ("k", ":", "d", "DR + oracle basis")}
+fig, ax = new_fig()
+for k, (c, ls, mk, lb) in S2.items():
+    ax.semilogy(snrs, [max(float(r[f"{k}_ser"]), 1e-4) for r in rows], ls,
+                color=c, marker=mk, label=lb)
+ax.set_xlabel("per-user SNR (dB)")
+ax.set_ylabel("semantic error rate")
+ax.set_ylim(3e-3, 2.7)
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="lower left", labelspacing=0.3)
+savefig(fig, "fig_e2_ladder.pdf")
+
+# ---------------------------------------------------------------- E3 time
+rows = load("e3_timeseries.csv")
+T = len(rows)
+t = np.arange(T)
+U = 4
+METHODS = ["OMA", "NOMA", "SR", "SC", "LMMSE", "DR-static", "DR-tracked",
+           "DR-genie"]
+S3 = {"DR-genie": ("k", ":"), "DR-tracked": ("tab:purple", "-"),
+      "DR-static": ("tab:orange", "--"), "SR": ("tab:red", "--"),
+      "SC": ("tab:green", "-."), "LMMSE": ("tab:blue", "-"),
+      "OMA": ("0.45", ":"), "NOMA": ("tab:brown", ":")}
+
+
+def roll(x, w=15):
+    """Moving average with edge-truncated windows (no zero-padding bias:
+    endpoints average only the samples that exist)."""
+    x = np.asarray(x, float)
+    num = np.convolve(x, np.ones(w), mode="same")
+    den = np.convolve(np.ones_like(x), np.ones(w), mode="same")
+    return num / den
+
+
+fig = plt.figure(figsize=(2.9, 4.2))
+_bh = 0.77 * 2.9 * 0.75 / 4.2            # same physical box height as new_fig
+axes = [fig.add_axes([0.185, 0.549, 0.77, _bh]),
+        fig.add_axes([0.185, 0.095, 0.77, _bh])]
+axes[0].tick_params(labelbottom=False)
+from matplotlib.lines import Line2D
+for u in range(U):
+    axes[0].plot(t, [float(r[f"a{u}"]) for r in rows], lw=1.1, color=f"C{u}")
+    axes[0].plot(t, [float(r[f"ahat{u}"]) for r in rows], lw=0.9, ls="--",
+                 color=f"C{u}", alpha=0.75)
+axes[0].set_ylabel("share coefficient $a_u(t)$")
+axes[0].set_ylim(0, 1.22)
+axes[0].legend(handles=[
+    Line2D([], [], color="k", ls="-", lw=1.1, label="true"),
+    Line2D([], [], color="k", ls="--", lw=0.9, label="tracked")],
+    loc="upper right", ncol=2, columnspacing=0.8)
+axes[0].grid(alpha=0.3)
+for m in METHODS:
+    c, ls = S3[m]
+    axes[1].semilogy(t, np.clip(roll([float(r[f"{m}_ser"]) for r in rows]),
+                                1e-3, None), ls, color=c, label=m)
+axes[1].set_xlabel("time slot $t$")
+axes[1].set_ylabel("semantic error rate")
+axes[1].set_ylim(2e-2, 30)
+axes[1].grid(True, which="both", alpha=0.3)
+axes[1].legend(loc="upper center", ncol=3, columnspacing=0.7,
+               handletextpad=0.4, labelspacing=0.3, fontsize=6)
+savefig(fig, "fig_e3_time.pdf")
+
+# ---------------------------------------------------------------- E3 speed
+rows = load("e3_speed.csv")
+speeds = [float(r["speed"]) for r in rows]
+marks = {"DR-genie": "d", "DR-tracked": "^", "DR-static": "s",
+         "SR": "v", "SC": "x", "LMMSE": "o", "OMA": "1", "NOMA": "P"}
+fig, ax = new_fig()
+for m in METHODS:
+    c, ls = S3[m]
+    ax.semilogy(speeds, [max(float(r[f"{m}_ser"]), 1e-4) for r in rows], ls,
+                color=c, marker=marks[m], label=m)
+ax.set_xlabel("user speed (m/slot)")
+ax.set_ylabel("mean semantic error rate")
+ax.set_ylim(0.1, 40)
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="upper center", ncol=3, columnspacing=0.6, handletextpad=0.3,
+          handlelength=1.4, labelspacing=0.25, fontsize=5.8, borderpad=0.3)
+savefig(fig, "fig_e3_speed.pdf")
+
+# ---------------------------------------------------------------- E4
+rows = load("e4_mismatch.csv")
+fig, ax = new_fig()
+for snr_db, c, mk in ((5, "tab:red", "s"), (10, "tab:blue", "o"),
+                      (15, "tab:green", "^")):
+    pts = [(float(r["delta"]), float(r["cos"])) for r in rows
+           if int(r["snr"]) == snr_db]
+    ax.plot([p[0] for p in pts], [p[1] for p in pts], "-", color=c,
+            marker=mk, label=f"{snr_db} dB")
+ax.set_xlabel(r"affinity estimation error $\delta$")
+ax.set_ylabel("mean cosine recovery")
+ax.set_ylim(0.40, 1.0)
+ax.grid(alpha=0.3)
+ax.legend(loc="upper center", ncol=3, columnspacing=0.9, handletextpad=0.4,
+          borderpad=0.3)
+savefig(fig, "fig_e4_mismatch.pdf")
+
+# ---------------------------------------------------------------- E5
+rows = load("e5_learned.csv")
+betas5 = [float(r["beta"]) for r in rows]
+fig, ax = new_fig()
+S5 = {"Learned": ("tab:red", "--", "s", "learned attention"),
+      "LMMSE": ("tab:blue", "-", "o", "LMMSE"),
+      "DR": ("k", "-", "d", "Proposed DR")}
+for k, (c, ls, mk, lb) in S5.items():
+    ax.semilogy(betas5, [max(float(r[f"{k}_ser"]), 1e-3) for r in rows], ls,
+                color=c, marker=mk, label=lb)
+ax.set_xlabel(r"affinity $\beta$")
+ax.set_ylabel("semantic error rate")
+ax.set_ylim(8e-3, 3.2)
+ax.grid(True, which="both", alpha=0.3)
+ax.legend(loc="lower left", labelspacing=0.3)
+savefig(fig, "fig_e5_learned.pdf")
+
+print("all figures regenerated")

code/semantic_mac.py

@@ -0,0 +1,377 @@
+"""
+Core library for the TMC paper:
+  "Structured Shared-Private Embedding Multiplexing for Semantic Multiple
+   Access in Dynamic Mobile Networks"
+
+Builds on the published shared-embedding multiple-access framework
+(Lee, Choi, Lee, IEEE JSAC 2026, doi 10.1109/JSAC.2025.3643816).
+
+Pipeline modeled here
+---------------------
+1. Content model (shared-scene decomposition), latent frame:
+       z_u = a_u [c; 0] + sqrt(1-a_u^2) [0; p_u]        (structured latent)
+   c in R^{d_c}: shared scene content, p_u in R^{d-d_c}: private content.
+   A frozen foundation encoder outputs RAW embeddings x_u = R z_u with an
+   unknown orthogonal mixing R (the encoder's arbitrary basis) -- the
+   structure is present but hidden in the coordinates.
+
+2. Matched-filter MAC front end (identical to the JSAC/AA-EDMA line):
+       tilde_x_u = x_u + sum_{v!=u} beta_uv (h_v/h_u) x_v + n_u,
+       Cov(n_u,n_w) = sigma^2 B_uw/(h_u h_w) I_d,  sigma^2 = 1/rho.
+
+3. Receivers: SR (cancel), SC (combine), B-aware LMMSE (optimal linear,
+   isotropic prior), and the decomposition receiver DR that knows the
+   shared-subspace basis V_c: BLUE-combining on the shared block +
+   SR cancellation and Wiener shrinkage on the private complement.
+
+4. Embedding-structure optimization: closed-form spectral recovery of V_c
+   from the cross-covariance of paired clean embeddings (GCCA-style), and a
+   channel-in-the-loop learned linear adapter refining it.
+
+5. Mobility: time-varying a_u(t) from user trajectories around a scene, and
+   a decision-directed EWMA affinity tracker.
+"""
+from __future__ import annotations
+import math
+import numpy as np
+
+TAU = 0.45  # SER threshold on cosine (same operating definition as prior work)
+
+
+def set_seed(seed: int):
+    np.random.seed(seed)
+
+
+# ----------------------------------------------------------------------
+#  Affinity utilities
+# ----------------------------------------------------------------------
+def affinity_matrix(a: np.ndarray) -> np.ndarray:
+    """B_uv = a_u a_v (u != v), B_uu = 1."""
+    a = np.asarray(a, dtype=np.float64)
+    B = np.outer(a, a)
+    np.fill_diagonal(B, 1.0)
+    return B
+
+
+# ----------------------------------------------------------------------
+#  Content generators
+# ----------------------------------------------------------------------
+def sample_latents_isotropic(batch, U, d, d_c, a, rng):
+    """Structured latents with isotropic random contents (unit norm).
+    Returns z of shape (batch, U, d): shared block = first d_c coords."""
+    a = np.broadcast_to(np.asarray(a, float), (batch, U)) \
+        if np.ndim(a) > 1 or np.ndim(a) == 1 else np.full((batch, U), float(a))
+    if a.shape != (batch, U):
+        a = np.broadcast_to(np.asarray(a, float), (batch, U))
+    z = np.zeros((batch, U, d))
+    c = rng.standard_normal((batch, d_c))
+    c /= np.linalg.norm(c, axis=1, keepdims=True)
+    p = rng.standard_normal((batch, U, d - d_c))
+    p /= np.linalg.norm(p, axis=2, keepdims=True)
+    z[:, :, :d_c] = a[:, :, None] * c[:, None, :]
+    z[:, :, d_c:] = np.sqrt(1.0 - a[:, :, None] ** 2) * p
+    return z
+
+
+class EmbeddingPool:
+    """Real PLM embedding pool (e.g., BERT AG-News, 8000 x 768).
+    Centered + unit-normalized; provides PCA coordinates so that structured
+    latents can be built from real semantic content."""
+
+    def __init__(self, X: np.ndarray):
+        X = np.asarray(X, dtype=np.float64)
+        self.mu = X.mean(axis=0, keepdims=True)
+        Xc = X - self.mu
+        Xc /= np.linalg.norm(Xc, axis=1, keepdims=True)
+        self.X = Xc
+        # PCA basis of the (centered, normalized) pool
+        _, S, Vt = np.linalg.svd(Xc, full_matrices=False)
+        self.pca = Vt            # (d, d) rows = principal directions
+        self.spectrum = S ** 2 / len(Xc)
+        self.N, self.d = Xc.shape
+
+    def pca_coords(self, idx, k):
+        """Top-k PCA coordinates of pool items idx, renormalized to unit."""
+        Y = self.X[idx] @ self.pca[:k].T
+        return Y / (np.linalg.norm(Y, axis=1, keepdims=True) + 1e-12)
+
+
+def sample_latents_pool(pool: EmbeddingPool, batch, U, d, d_c, a, rng,
+                        idx_pool=None):
+    """Structured latents whose shared/private contents are REAL embeddings:
+    shared c = top-d_c PCA coords of one pool sentence, private p_u =
+    top-(d-d_c) PCA coords of distinct other sentences.
+
+    idx_pool: optional index array restricting which pool sentences may be
+    drawn (train/holdout partition); None draws from the whole pool."""
+    a = np.broadcast_to(np.asarray(a, float), (U,))
+    choices = np.arange(pool.N) if idx_pool is None else np.asarray(idx_pool)
+    idx = np.array([rng.choice(choices, size=U + 1, replace=False)
+                    for _ in range(batch)])
+    c = pool.pca_coords(idx[:, 0], d_c)                     # (batch, d_c)
+    z = np.zeros((batch, U, d))
+    for u in range(U):
+        p = pool.pca_coords(idx[:, u + 1], d - d_c)
+        z[:, u, :d_c] = a[u] * c
+        z[:, u, d_c:] = math.sqrt(1.0 - a[u] ** 2) * p
+    return z
+
+
+def random_orthogonal(d, rng):
+    G = rng.standard_normal((d, d))
+    Q, Rr = np.linalg.qr(G)
+    Q *= np.sign(np.diag(Rr))
+    return Q
+
+
+# ----------------------------------------------------------------------
+#  Matched-filter MAC front end (JSAC / AA-EDMA convention)
+# ----------------------------------------------------------------------
+def matched_filter(e, B, rho, rng, fading=True):
+    """tilde_u = sum_v (h_v/h_u) B_uv e_v + n_u,
+    Cov(n_u,n_w) = (sigma^2 B_uw / (h_u h_w)) I_d.  Returns (tilde, h)."""
+    batch, U, d = e.shape
+    sigma2 = 1.0 / rho
+    B = np.asarray(B, dtype=np.float64)
+    if B.ndim == 2:
+        B = np.broadcast_to(B, (batch, U, U))
+    if fading:
+        hc = (rng.standard_normal((batch, U)) +
+              1j * rng.standard_normal((batch, U))) / math.sqrt(2)
+        h = np.clip(np.abs(hc), 0.2, None)
+    else:
+        h = np.ones((batch, U))
+    tilde = np.einsum('buv,bvd,bv,bu->bud', B, e, h, 1.0 / h)
+    xi = rng.standard_normal((batch, U, d)) * math.sqrt(sigma2)
+    for b in range(batch):
+        A = np.linalg.cholesky(B[b])
+        tilde[b] += (A @ xi[b]) / h[b][:, None]
+    return tilde, h
+
+
+# ----------------------------------------------------------------------
+#  Receivers
+# ----------------------------------------------------------------------
+def demux_sr(tilde, B, h):
+    """Similarity-rejecting closed-form demux: (Gamma^{-1} (x) I) tilde."""
+    batch, U, d = tilde.shape
+    out = np.empty_like(tilde)
+    for b in range(batch):
+        Gamma = np.diag(1.0 / h[b]) @ B @ np.diag(h[b])
+        out[b] = np.linalg.solve(Gamma, tilde[b])
+    return out
+
+
+def demux_sc(tilde, h):
+    """Similarity-combining endpoint: h^2-weighted MRC of all MF outputs."""
+    w = h ** 2
+    w = w / w.sum(axis=1, keepdims=True)
+    comb = np.einsum('bu,bud->bd', w, tilde)
+    return np.repeat(comb[:, None, :], tilde.shape[1], axis=1)
+
+
+def lmmse_matrices(B, h, sigma2, d):
+    H = np.diag(h)
+    Hi = np.diag(1.0 / h)
+    Gamma = Hi @ B @ H
+    Cx = B / d
+    Cn = sigma2 * (Hi @ B @ Hi)
+    S = Gamma @ Cx @ Gamma.T + Cn
+    W = np.linalg.solve(S.T, (Cx @ Gamma.T).T).T
+    Eerr = Cx - W @ Gamma @ Cx
+    return W, Eerr
+
+
+def demux_lmmse(tilde, B, h, rho):
+    """B-aware LMMSE (optimal linear receiver under isotropic prior).
+    Returns (estimates, closed-form per-user total MSE averaged over batch)."""
+    batch, U, d = tilde.shape
+    sigma2 = 1.0 / rho
+    out = np.empty_like(tilde)
+    mse_cf = np.zeros(U)
+    for b in range(batch):
+        W, Eerr = lmmse_matrices(B, h[b], sigma2, d)
+        out[b] = W @ tilde[b]
+        mse_cf += d * np.diag(Eerr)
+    return out, mse_cf / batch
+
+
+def demux_dr(tilde, B, h, rho, a, Vc):
+    """Decomposition receiver (proposed).
+
+    Vc: (d, d_c) orthonormal basis of the shared subspace (from the
+    embedding-structure optimizer; oracle = true mixing columns).
+    Shared block: BLUE-combining of the U looks at the common content,
+    followed by Wiener shrinkage.  Private complement: SR cancellation +
+    per-user Wiener shrinkage.  Recombine."""
+    batch, U, d = tilde.shape
+    d_c = Vc.shape[1]
+    sigma2 = 1.0 / rho
+    a = np.broadcast_to(np.asarray(a, float), (U,))
+    Binv = np.linalg.inv(B)
+    out = np.empty_like(tilde)
+    Zs = tilde @ Vc                          # (batch, U, d_c) shared-block obs
+    Zp = tilde - (Zs @ Vc.T)                 # complement part (in ambient frame)
+    for b in range(batch):
+        hb = h[b]
+        Hi = np.diag(1.0 / hb)
+        Gamma = Hi @ B @ np.diag(hb)
+        Cn = sigma2 * (Hi @ B @ Hi)
+        gamma = np.array([
+            a[u] + sum(B[u, v] * a[v] * hb[v] / hb[u]
+                       for v in range(U) if v != u) for u in range(U)])
+        Cn_inv = np.linalg.inv(Cn)
+        denom = float(gamma @ Cn_inv @ gamma)
+        if denom > 1e-12:
+            c_hat = (gamma @ Cn_inv @ Zs[b]) / denom
+            c_hat *= (1.0 / d_c) / (1.0 / d_c + 1.0 / denom)
+        else:
+            c_hat = np.zeros(d_c)
+        Gp = np.linalg.solve(Gamma, Zp[b])   # SR on the complement
+        for u in range(U):
+            sig_p = 1.0 - a[u] ** 2
+            err_p = (d - d_c) * sigma2 * Binv[u, u] / hb[u] ** 2
+            shrink = sig_p / (sig_p + err_p) if sig_p > 0 else 0.0
+            out[b, u] = a[u] * (Vc @ c_hat) + shrink * Gp[u]
+    return out
+
+
+# ----------------------------------------------------------------------
+#  Conventional baselines (orthogonal and power-domain multiple access)
+# ----------------------------------------------------------------------
+def oma_observe(e, h, rho, rng):
+    """Conventional orthogonal MA (OFDMA-style): user u is confined to a
+    disjoint d/U-dimensional block and decoded only from that block, so it
+    never sees cross-user interference but its recovery is capped by the
+    1/U-energy subspace (cosine ceiling ~ sqrt(1/U))."""
+    batch, U, d = e.shape
+    blk = d // U
+    sigma = math.sqrt(1.0 / rho)
+    out = np.zeros_like(e)
+    for u in range(U):
+        sl = slice(u * blk, (u + 1) * blk)
+        out[:, u, sl] = e[:, u, sl] + \
+            rng.standard_normal((batch, blk)) * sigma / h[:, u][:, None]
+    return out
+
+
+def demux_noma_genie(e, h, rho, rng):
+    """Genie-aided NOMA-SIC upper bound: every user decoded from an
+    interference-free observation e_u + n/h_u at per-user SNR rho
+    (perfect cancellation, no error propagation)."""
+    batch, U, d = e.shape
+    sigma = math.sqrt(1.0 / rho)
+    return e + rng.standard_normal(e.shape) * sigma / h[:, :, None]
+
+
+# ----------------------------------------------------------------------
+#  Embedding-structure optimization
+# ----------------------------------------------------------------------
+def learn_structure_spectral(x_clean, d_c):
+    """Closed-form shared-subspace recovery from N paired CLEAN embeddings.
+
+    x_clean: (N, U, d) raw (mixed) embeddings of co-located users.
+    The averaged symmetrized cross-covariance has column space equal to the
+    shared subspace (private parts are independent and average out).
+    Returns Vc_hat (d, d_c), eigenvalues (d,)."""
+    N, U, d = x_clean.shape
+    M = np.zeros((d, d))
+    cnt = 0
+    for u in range(U):
+        for v in range(u + 1, U):
+            C = x_clean[:, u, :].T @ x_clean[:, v, :] / N
+            M += C + C.T
+            cnt += 2
+    M /= cnt
+    w, V = np.linalg.eigh(M)
+    order = np.argsort(w)[::-1]
+    return V[:, order[:d_c]], w[order]
+
+
+def subspace_error(Vhat, Vtrue):
+    """Normalized projection-Frobenius distance in [0,1]."""
+    P1 = Vhat @ Vhat.T
+    P2 = Vtrue @ Vtrue.T
+    k = Vtrue.shape[1]
+    return float(np.linalg.norm(P1 - P2) / math.sqrt(2 * k))
+
+
+def estimate_a_from_clean(x_clean, Vc):
+    """a_u estimate from clean paired data: sqrt(mean shared-block energy)."""
+    E = np.linalg.norm(x_clean @ Vc, axis=2) ** 2      # (N, U)
+    return np.sqrt(np.clip(E.mean(axis=0), 0.0, 1.0))
+
+
+# ----------------------------------------------------------------------
+#  Mobility model and online affinity tracking
+# ----------------------------------------------------------------------
+def mobility_trajectories(U, T, speed, rng, box=60.0, r_scene=28.0,
+                          a_max=0.95, dt=1.0):
+    """Random-waypoint trajectories around a scene at the origin.
+    Returns a_t of shape (T, U): a_u(t) = a_max * exp(-d_u(t)^2 / (2 r^2))."""
+    pos = rng.uniform(-box, box, size=(U, 2))
+    wp = rng.uniform(-box, box, size=(U, 2))
+    a_t = np.zeros((T, U))
+    for t in range(T):
+        for u in range(U):
+            vec = wp[u] - pos[u]
+            dist = np.linalg.norm(vec)
+            if dist < speed * dt:
+                wp[u] = rng.uniform(-box, box, size=2)
+            else:
+                pos[u] += (speed * dt) * vec / dist
+        d2 = (pos ** 2).sum(axis=1)
+        a_t[t] = a_max * np.exp(-d2 / (2 * r_scene ** 2))
+    return a_t
+
+
+def pilot_affinity_obs(e_clean, h, rho, rng, a_cap=0.95):
+    """Affinity observation from one orthogonal pilot slot.
+
+    Each user transmits n_p clean embeddings on an interference-free pilot
+    resource; the receiver observes e_u + n/h_u.  Off-diagonal Gram entries
+    of the pilot observations are unbiased for beta_uv = a_u a_v (independent
+    noises), so no bias correction is needed.  The share coefficients are
+    then the rank-one alternating-least-squares fit of the off-diagonal
+    Gram, which uses all pairs jointly."""
+    n_p, U, d = e_clean.shape
+    sigma = math.sqrt(1.0 / rho)
+    y = e_clean + rng.standard_normal(e_clean.shape) * sigma / h[None, :, None]
+    G = np.einsum('bud,bvd->buv', y, y).mean(axis=0)
+    # rank-1 least-squares fit of the off-diagonal Gram: G_uv ~ a_u a_v.
+    # Alternating least squares; uses all pairs jointly (no small-denominator
+    # amplification, robust in low-affinity regimes).
+    mask = ~np.eye(U, dtype=bool)
+    a = np.sqrt(np.clip(np.abs(G[mask]).reshape(U, U - 1).mean(axis=1),
+                        1e-4, a_cap ** 2))
+    for _ in range(20):
+        for u in range(U):
+            others = [v for v in range(U) if v != u]
+            num = sum(G[u, v] * a[v] for v in others)
+            den = sum(a[v] ** 2 for v in others) + 1e-9
+            a[u] = np.clip(num / den, 0.0, a_cap)
+    return a
+
+
+class AffinityTracker:
+    """EWMA tracker of the per-user share coefficients, driven by sparse
+    orthogonal affinity-pilot observations (every K-th slot)."""
+
+    def __init__(self, U, lam=0.5, a_init=0.3):
+        self.a = np.full(U, float(a_init))
+        self.lam = lam
+
+    def update(self, obs):
+        self.a = (1 - self.lam) * self.a + self.lam * obs
+        return self.a.copy()
+
+
+# ----------------------------------------------------------------------
+#  Metrics
+# ----------------------------------------------------------------------
+def metrics(e_hat, e_true, tau=TAU):
+    """(mean cosine, NMSE of raw estimate, SER). e_true unit-norm."""
+    nmse = ((e_hat - e_true) ** 2).sum(-1).mean()
+    e_n = e_hat / (np.linalg.norm(e_hat, axis=2, keepdims=True) + 1e-12)
+    cos = (e_n * e_true).sum(-1)
+    return float(cos.mean()), float(nmse), float((cos < tau).mean())

data/e1_beta.csv

@@ -0,0 +1,13 @@
+beta,OMA_cos,OMA_nmse,OMA_ser,NOMA_cos,NOMA_nmse,NOMA_ser,SR_cos,SR_nmse,SR_ser,SC_cos,SC_nmse,SC_ser,LMMSE_cos,LMMSE_nmse,LMMSE_ser,DR_cos,DR_nmse,DR_ser,LMMSE_cf,SR_cf
+0.0,0.1518317330826309,6.586330527939255,0.959625,0.3181139435479019,23.34841450901824,0.7524375,0.3203064428538257,23.363609989171813,0.7501875,0.17164555154884942,3.0238373778749565,0.92575,0.32030644285293924,0.8764057280548786,0.7501875,0.3600089003351096,0.8456005907022793,0.6493125,0.8772111710642737,23.366080084700258
+0.1,0.15589537469644302,6.521926618788019,0.9763125,0.31997502436434877,23.225337129468034,0.754875,0.31284660475379716,23.730001190599637,0.763125,0.23544768908222563,3.4903701062781507,0.8906875,0.3286372303744752,0.8727398586878315,0.7405625,0.35720726032200956,0.8547067798024575,0.6945625,0.8715244945854621,23.72957048015672
+0.2,0.1579600361307968,6.614980306151368,0.987375,0.3185588103483156,23.508441790061838,0.751875,0.3071834075254276,25.664328592045972,0.7783125,0.3081174324577614,4.005316225325675,0.812,0.36550409107776605,0.8499929422094927,0.682125,0.40671100402630883,0.8230295356725337,0.6233125,0.8507143520638605,25.69980387077865
+0.3,0.15717310964229558,6.752916642082322,0.994,0.3164878434145981,23.696387090171708,0.7530625,0.29445075096761586,28.440139195119926,0.8049375,0.3737395538453454,4.6587701688046295,0.6950625,0.4086155050165615,0.8194653748516086,0.5948125,0.4699443359376159,0.7722928549119525,0.417875,0.8201178016615405,28.580023318985315
+0.4,0.1558822753077902,6.6437034711419605,0.978375,0.3164742195632639,23.66478210451729,0.7599375,0.2769676652160525,32.444156006235005,0.8381875,0.4418585784086807,5.390751440360708,0.5049375,0.4613567748591795,0.7761485754085672,0.4405,0.5398910109925175,0.7050765664812834,0.1525,0.7770407374526299,32.48112657790815
+0.5,0.15360527772566732,6.633239860501342,0.944625,0.31715069454661715,23.447958786145506,0.75475,0.25939760032458,37.9029280453721,0.863125,0.5089881795141582,6.112173611529999,0.295125,0.5194020166749006,0.7210471246656404,0.27625,0.6135763351967299,0.6228748060632902,0.040375,0.7210770148831555,37.706128740179714
+0.6,0.15104564175436277,6.618673493235747,0.9116875,0.3190950040803634,23.416481776933132,0.7530625,0.23746214819997877,46.35364132822288,0.9024375,0.5707667910192523,7.18280130135221,0.1493125,0.5758052496354826,0.660406791149609,0.1425625,0.6819684891445188,0.5356249676777529,0.013125,0.6599324369708673,46.1616297815643
+0.7,0.14658858300872607,6.579769667930802,0.8839375,0.32042413207660686,23.514174872716637,0.747625,0.21066438792031572,60.810052175317615,0.9381875,0.6343326125709531,8.10391365259618,0.0605,0.6363145967300298,0.5883586517475555,0.0596875,0.7510884530926762,0.4378598835689139,0.003375,0.5892740628870172,60.610239784779516
+0.8,0.14224189962411288,6.622528089700304,0.863625,0.31737825140661446,23.64121074958681,0.756625,0.17298207341260183,89.9827978067193,0.9758125,0.6877230749032447,9.765603569825602,0.024,0.6882760858443637,0.5202873216426361,0.0241875,0.8130141518262433,0.3422131407972644,0.001,0.5205576308634045,90.28865373539367
+0.9,0.13944820649328607,6.569145530014273,0.845375,0.32012185641929314,23.216830674651195,0.7480625,0.12650489700035406,175.19880610441587,0.99175,0.7479378327622059,11.000473435774282,0.0083125,0.7479995494170205,0.43557216499125984,0.008375,0.8773177840178794,0.2338632107538353,0.00025,0.4365956865370872,175.29563270069005
+0.95,0.13473445421784822,6.815045356624257,0.8416875,0.31610426991277907,23.97238509906978,0.758875,0.08894962614416471,361.0614537517205,0.9975,0.7706709862528589,12.089902333536367,0.0055625,0.7706796603551158,0.40107886284395255,0.0055,0.9057814222318477,0.18350754366484087,0.0,0.40282220832244586,360.92744714649893
+0.99,0.13406057397656254,6.568080314769884,0.8314375,0.31788730006984517,23.26036208135335,0.750875,0.04023444150109489,1749.9325770225032,0.999875,0.7935678421099195,12.769035629640939,0.0036875,0.7935677633822752,0.365692686465036,0.0036875,0.929869722575857,0.13942791833909166,0.0,0.36656833489816454,1753.2181983014361

data/e1_endpoints.txt

@@ -0,0 +1,4 @@
+(i) rho=10dB rel_diff_W_vs_Gammainv=9.940e-01
+(i) rho=40dB rel_diff_W_vs_Gammainv=1.771e-01
+(i) rho=80dB rel_diff_W_vs_Gammainv=2.322e-05
+(ii) beta=0 max_offdiag=0.000e+00 max_diag_minus_wiener=2.776e-17

data/e1_snr.csv

@@ -0,0 +1,7 @@
+snr,OMA_cos,OMA_nmse,OMA_ser,NOMA_cos,NOMA_nmse,NOMA_ser,SR_cos,SR_nmse,SR_ser,SC_cos,SC_nmse,SC_ser,LMMSE_cos,LMMSE_nmse,LMMSE_ser,DR_cos,DR_nmse,DR_ser
+0,0.05350647232668011,58.85600942888945,0.99925,0.10890134987091221,233.83806869578348,0.9959375,0.09517362162512003,317.6743429018145,0.9976875,0.17927412348574373,42.90806295709593,0.98675,0.18449745469042939,0.9630179128139159,0.9833125,0.25411820225537163,0.9315293277360746,0.93525
+4,0.08456820266401209,24.38310213293538,0.9975625,0.17043345938432167,94.4298962129786,0.97325,0.14744124682792525,128.6041916804174,0.9869375,0.26844480706147605,17.938066560437775,0.918375,0.2769703001989752,0.9174622143307749,0.9055625,0.36494032979819524,0.8623869866478949,0.73975
+8,0.12847320402849005,9.94588160014589,0.9883125,0.26116503748884695,36.8529237481926,0.8645,0.22668242977056338,50.22310372984251,0.91925,0.3833396462883285,7.612540791885531,0.678625,0.39792555428763177,0.8321657950063345,0.632625,0.4841163218378676,0.7616303217248894,0.32175
+12,0.18798873630558025,4.4738249745662335,0.9569375,0.38294513861040697,14.962780371484499,0.609875,0.3370208676912972,20.316950947249193,0.7103125,0.5016307965715139,3.7178839382237685,0.3340625,0.5278359362414502,0.709593380592026,0.2794375,0.5942117410027357,0.6439496405799463,0.0543125
+16,0.2582251812343568,2.242220410434714,0.8835,0.5271717432396316,5.9432601195927495,0.3329375,0.4770268495835736,8.119497948199752,0.4200625,0.5972454380791258,2.166496018630578,0.1176875,0.6471520815297644,0.5689058943246919,0.0785,0.6887024096495977,0.5210923893293615,0.0040625
+20,0.33092058522338036,1.3274083828855985,0.7794375,0.6774072574643101,2.314718955325978,0.1501875,0.6286005332183222,3.156716159460809,0.198375,0.658990514110599,1.5281586204071873,0.038125,0.7475910751137647,0.4292425872558179,0.0154375,0.7753764048787856,0.3921981791242343,0.000125

data/e2_caliberr.txt

@@ -0,0 +1,2 @@
+spectral_err=0.5066663187245027
+adapter_err=0.47115266508068226

data/e2_exponents.txt

@@ -0,0 +1,3 @@
+U=2 exponent=-0.355
+U=4 exponent=-0.466
+U=8 exponent=-0.506

data/e2_ladder.csv

@@ -0,0 +1,7 @@
+snr,OMA_cos,OMA_nmse,OMA_ser,NOMA_cos,NOMA_nmse,NOMA_ser,LMMSE_cos,LMMSE_nmse,LMMSE_ser,DR-spec_cos,DR-spec_nmse,DR-spec_ser,DR-adapt_cos,DR-adapt_nmse,DR-adapt_ser,DR-oracle_cos,DR-oracle_nmse,DR-oracle_ser
+0,0.015926856588632552,708.1410662348101,1.0,0.032366678990131355,2825.9296694091063,1.0,0.06504128995173108,0.9954549368433073,1.0,0.11363743483582082,0.9864432255544942,1.0,0.11269793069195441,0.9866853941365498,1.0,0.12461558948397138,0.9835291297200829,1.0
+4,0.02527539949479218,282.4034369499902,1.0,0.05024038177607893,1125.4082835768606,1.0,0.1017511108993672,0.9888174714074848,1.0,0.17546427522174937,0.9675286696275514,0.999875,0.17393473783073346,0.9681414367311848,0.9999375,0.19191140170951212,0.9608993709219992,1.0
+8,0.040710908014543294,110.98837975825798,1.0,0.08027572155744378,441.3279450915458,1.0,0.1616753798128203,0.971988429624148,1.0,0.2666360280147621,0.9259323237134416,0.99425,0.26479087268827234,0.9270159552407004,0.99675,0.2903226264007727,0.9118051394274336,0.98525
+12,0.06287856250955912,45.229771715034616,1.0,0.1263380541254036,178.04760341015174,0.9999375,0.24559671354120155,0.9356679370889158,0.997125,0.3759920842184834,0.8544944634682347,0.8074375,0.37444823190582976,0.8557139013732603,0.823875,0.4068568033891352,0.8293182890007151,0.67225
+16,0.09633285159207082,18.885104681139087,1.0,0.19264673455405848,72.5869101062965,0.992125,0.3564850168024069,0.8662547548440153,0.8510625,0.48656498483446015,0.7596969881164621,0.2864375,0.4858341019159984,0.7603977077146976,0.278125,0.5228884527504853,0.7225489380317694,0.146875
+20,0.1475220708435571,7.865315077959365,1.0,0.29484108980442747,28.53588215213648,0.8525,0.49229395095582795,0.7485442569919676,0.33825,0.5835687315046603,0.6570088460516684,0.033125,0.5853487711485057,0.6548171643846629,0.0274375,0.6229976583065931,0.6094375297390521,0.0100625

data/e2_subspace_multi.csv

@@ -0,0 +1,19 @@
+U,N,err
+2,200,0.6015688232533535
+2,400,0.5100480469623787
+2,800,0.4163137765895379
+2,1600,0.3274723671925073
+2,3200,0.24614586168567973
+2,6400,0.17418725655145126
+4,200,0.5040386164337312
+4,400,0.38630798361019253
+4,800,0.2837206544692833
+4,1600,0.20320111590214116
+4,3200,0.14395409260595776
+4,6400,0.1017848037055953
+8,200,0.415403307029665
+8,400,0.28727521612595036
+8,800,0.20027604274397937
+8,1600,0.14237997170149888
+8,3200,0.10045651014386626
+8,6400,0.07158722970583854

data/e3_speed.csv

@@ -0,0 +1,6 @@
+speed,DR-genie_cos,DR-genie_ser,DR-tracked_cos,DR-tracked_ser,DR-static_cos,DR-static_ser,SR_cos,SR_ser,SC_cos,SC_ser,LMMSE_cos,LMMSE_ser,OMA_cos,OMA_ser,NOMA_cos,NOMA_ser
+0.5,0.5794649360598771,0.21950748697916667,0.5739841001040412,0.23187109375,0.5664720141351067,0.2484931640625,0.33440327011050436,0.7142825520833334,0.46051384076723956,0.45970442708333337,0.5105068703916773,0.3414085286458333,0.2018708801770776,0.9102161458333333,0.3833148683402804,0.6103043619791666
+1.0,0.6166347710164346,0.15714420572916668,0.6090281513566702,0.1726455078125,0.6015407405294093,0.18871158854166667,0.3214097476604759,0.7414912109375,0.5010390265031732,0.36549576822916663,0.540881364251173,0.2731194661458333,0.18394033256730064,0.9169586588541666,0.38323034831255015,0.6104072265625
+2.0,0.5970751793253375,0.18801302083333332,0.5848245272847403,0.21389811197916667,0.5794199453050508,0.22403548177083332,0.3287948013878244,0.7263095703125,0.47766237602611283,0.4160784505208333,0.5235681251295078,0.3093792317708334,0.18301300897898432,0.9250042317708332,0.3833082213921645,0.610365234375
+4.0,0.6001377391058428,0.18024674479166666,0.5839354683364975,0.2146298828125,0.5829994680307478,0.21672916666666667,0.32796168761947786,0.7281370442708333,0.48253072400293356,0.40805566406250005,0.526849532788922,0.3038763020833333,0.18224146474411818,0.9273326822916668,0.38328927198557355,0.6105133463541667
+8.0,0.6079273767470954,0.16943294270833334,0.5910829910661712,0.2040139973958333,0.591289877824418,0.20492415364583333,0.32440369135066427,0.7352037760416665,0.49192580974071415,0.38576953125,0.5338899294845367,0.2882327473958333,0.18226056441346877,0.9237444661458333,0.3832524105168856,0.6103388671875001

data/e3_timeseries.csv

@@ -0,0 +1,301 @@
+t,a0,a1,a2,a3,ahat0,ahat1,ahat2,ahat3,DR-genie_ser,DR-tracked_ser,DR-static_ser,SR_ser,SC_ser,LMMSE_ser,OMA_ser,NOMA_ser
+0,0.2250,0.0928,0.0567,0.0507,0.3119,0.2561,0.4011,0.2903,0.5273,0.5888,0.5834,0.6133,0.8700,0.6125,0.9294,0.6123
+1,0.2320,0.0952,0.0572,0.0507,0.3119,0.2561,0.4011,0.2903,0.5212,0.5836,0.5794,0.6103,0.8700,0.6097,0.9291,0.6166
+2,0.2392,0.0977,0.0577,0.0508,0.3119,0.2561,0.4011,0.2903,0.5259,0.5856,0.5872,0.6130,0.8794,0.6133,0.9241,0.6170
+3,0.2466,0.1003,0.0583,0.0509,0.3119,0.2561,0.4011,0.2903,0.5252,0.5813,0.5798,0.6102,0.8719,0.6086,0.9264,0.6033
+4,0.2542,0.1030,0.0588,0.0509,0.3119,0.2561,0.4011,0.2903,0.5336,0.5897,0.5920,0.6139,0.8764,0.6125,0.9322,0.6125
+5,0.2619,0.1059,0.0594,0.0510,0.5030,0.1793,0.3190,0.2032,0.5208,0.5703,0.5789,0.6025,0.8717,0.6022,0.9308,0.6103
+6,0.2699,0.1088,0.0601,0.0511,0.5030,0.1793,0.3190,0.2032,0.5303,0.5831,0.5908,0.6148,0.8770,0.6128,0.9258,0.6038
+7,0.2780,0.1119,0.0608,0.0512,0.5030,0.1793,0.3190,0.2032,0.5386,0.5878,0.5966,0.6236,0.8736,0.6238,0.9278,0.6130
+8,0.2863,0.1151,0.0615,0.0513,0.5030,0.1793,0.3190,0.2032,0.5242,0.5745,0.5795,0.6033,0.8666,0.6034,0.9298,0.6111
+9,0.2948,0.1185,0.0623,0.0514,0.5030,0.1793,0.3190,0.2032,0.5277,0.5741,0.5800,0.6005,0.8716,0.5991,0.9255,0.6047
+10,0.3035,0.1220,0.0631,0.0515,0.4108,0.1579,0.2431,0.4273,0.5241,0.5627,0.5805,0.6028,0.8634,0.6011,0.9298,0.6086
+11,0.3124,0.1256,0.0640,0.0517,0.4108,0.1579,0.2431,0.4273,0.5330,0.5730,0.5892,0.6098,0.8692,0.6103,0.9214,0.6083
+12,0.3214,0.1294,0.0649,0.0518,0.4108,0.1579,0.2431,0.4273,0.5175,0.5573,0.5770,0.5992,0.8706,0.5977,0.9298,0.6055
+13,0.3306,0.1333,0.0658,0.0519,0.4108,0.1579,0.2431,0.4273,0.5214,0.5614,0.5775,0.6005,0.8695,0.5992,0.9269,0.6103
+14,0.3399,0.1373,0.0669,0.0521,0.4108,0.1579,0.2431,0.4273,0.5339,0.5711,0.5881,0.6158,0.8750,0.6136,0.9289,0.6072
+15,0.3495,0.1415,0.0679,0.0523,0.4012,0.1882,0.4552,0.2991,0.5292,0.5769,0.5823,0.6058,0.8677,0.6059,0.9295,0.6125
+16,0.3592,0.1459,0.0691,0.0524,0.4012,0.1882,0.4552,0.2991,0.5467,0.5944,0.5983,0.6202,0.8708,0.6175,0.9270,0.6155
+17,0.3690,0.1505,0.0703,0.0526,0.4012,0.1882,0.4552,0.2991,0.5298,0.5845,0.5883,0.6097,0.8705,0.6059,0.9270,0.6138
+18,0.3790,0.1551,0.0715,0.0528,0.4012,0.1882,0.4552,0.2991,0.5325,0.5844,0.5884,0.6083,0.8681,0.6073,0.9284,0.6131
+19,0.3892,0.1600,0.0729,0.0531,0.4012,0.1882,0.4552,0.2991,0.5262,0.5748,0.5798,0.6038,0.8688,0.6009,0.9262,0.5967
+20,0.3994,0.1650,0.0743,0.0533,0.4049,0.1317,0.6036,0.3308,0.5277,0.5783,0.5875,0.6069,0.8684,0.6033,0.9245,0.6103
+21,0.4099,0.1702,0.0758,0.0535,0.4049,0.1317,0.6036,0.3308,0.5394,0.5845,0.5913,0.6156,0.8620,0.6119,0.9273,0.6080
+22,0.4204,0.1756,0.0773,0.0538,0.4049,0.1317,0.6036,0.3308,0.5347,0.5831,0.5887,0.6070,0.8667,0.6033,0.9255,0.6025
+23,0.4311,0.1812,0.0789,0.0541,0.4049,0.1317,0.6036,0.3308,0.5403,0.5866,0.5909,0.6128,0.8655,0.6106,0.9280,0.6108
+24,0.4419,0.1869,0.0807,0.0544,0.4049,0.1317,0.6036,0.3308,0.5308,0.5802,0.5848,0.6064,0.8623,0.6011,0.9292,0.6003
+25,0.4528,0.1928,0.0825,0.0547,0.3265,0.3772,0.4360,0.2932,0.5417,0.5858,0.5961,0.6173,0.8670,0.6100,0.9353,0.6155
+26,0.4637,0.1989,0.0843,0.0551,0.3265,0.3772,0.4360,0.2932,0.5345,0.5819,0.5873,0.6089,0.8630,0.6017,0.9331,0.6089
+27,0.4748,0.2051,0.0863,0.0555,0.3265,0.3772,0.4360,0.2932,0.5502,0.5936,0.5984,0.6209,0.8606,0.6133,0.9344,0.6214
+28,0.4860,0.2116,0.0884,0.0559,0.3265,0.3772,0.4360,0.2932,0.5411,0.5923,0.6003,0.6134,0.8591,0.6067,0.9269,0.6058
+29,0.4972,0.2182,0.0906,0.0563,0.3265,0.3772,0.4360,0.2932,0.5495,0.5944,0.5973,0.6189,0.8656,0.6119,0.9283,0.6184
+30,0.5085,0.2250,0.0928,0.0567,0.4766,0.5490,0.3485,0.2317,0.5328,0.6008,0.5933,0.6148,0.8562,0.6062,0.9338,0.6098
+31,0.5198,0.2320,0.0952,0.0572,0.4766,0.5490,0.3485,0.2317,0.5447,0.6103,0.6064,0.6244,0.8631,0.6164,0.9295,0.6209
+32,0.5312,0.2392,0.0977,0.0577,0.4766,0.5490,0.3485,0.2317,0.5303,0.5992,0.5927,0.6075,0.8480,0.5983,0.9319,0.6088
+33,0.5427,0.2466,0.1003,0.0583,0.4766,0.5490,0.3485,0.2317,0.5339,0.6067,0.5964,0.6164,0.8613,0.6045,0.9302,0.6134
+34,0.5541,0.2542,0.1030,0.0588,0.4766,0.5490,0.3485,0.2317,0.5355,0.6072,0.6022,0.6194,0.8588,0.6108,0.9250,0.6134
+35,0.5656,0.2619,0.1059,0.0594,0.3811,0.6096,0.2801,0.1622,0.5230,0.5736,0.5909,0.6088,0.8556,0.5911,0.9228,0.6036
+36,0.5770,0.2699,0.1088,0.0601,0.3811,0.6096,0.2801,0.1622,0.5256,0.5731,0.5887,0.6123,0.8573,0.5986,0.9208,0.6100
+37,0.5884,0.2780,0.1119,0.0608,0.3811,0.6096,0.2801,0.1622,0.5294,0.5783,0.5988,0.6175,0.8527,0.6028,0.9170,0.6067
+38,0.5999,0.2863,0.1151,0.0615,0.3811,0.6096,0.2801,0.1622,0.5267,0.5800,0.5942,0.6159,0.8444,0.5978,0.9097,0.6155
+39,0.6113,0.2948,0.1185,0.0623,0.3811,0.6096,0.2801,0.1622,0.5228,0.5780,0.5947,0.6194,0.8447,0.5984,0.9053,0.6178
+40,0.6226,0.3035,0.1220,0.0631,0.2668,0.4267,0.1960,0.1135,0.5003,0.5559,0.5800,0.6056,0.8361,0.5806,0.9008,0.6062
+41,0.6339,0.3124,0.1256,0.0640,0.2668,0.4267,0.1960,0.1135,0.5122,0.5678,0.5927,0.6200,0.8398,0.5938,0.9005,0.6119
+42,0.6451,0.3214,0.1294,0.0649,0.2668,0.4267,0.1960,0.1135,0.4987,0.5620,0.5847,0.6202,0.8366,0.5878,0.8869,0.6164
+43,0.6562,0.3306,0.1333,0.0658,0.2668,0.4267,0.1960,0.1135,0.4970,0.5578,0.5787,0.6139,0.8289,0.5842,0.8809,0.6106
+44,0.6672,0.3399,0.1373,0.0669,0.2668,0.4267,0.1960,0.1135,0.4925,0.5522,0.5767,0.6172,0.8331,0.5837,0.8803,0.6139
+45,0.6781,0.3495,0.1415,0.0679,0.4306,0.3402,0.4222,0.1214,0.4931,0.5739,0.5825,0.6219,0.8305,0.5845,0.8722,0.6048
+46,0.6889,0.3592,0.1459,0.0691,0.4306,0.3402,0.4222,0.1214,0.4914,0.5734,0.5863,0.6280,0.8322,0.5906,0.8719,0.6147
+47,0.6996,0.3690,0.1505,0.0703,0.4306,0.3402,0.4222,0.1214,0.4875,0.5788,0.5845,0.6341,0.8200,0.5848,0.8697,0.6100
+48,0.7101,0.3790,0.1551,0.0715,0.4306,0.3402,0.4222,0.1214,0.4661,0.5564,0.5689,0.6172,0.8206,0.5650,0.8488,0.6011
+49,0.7205,0.3892,0.1600,0.0729,0.4306,0.3402,0.4222,0.1214,0.4719,0.5667,0.5809,0.6359,0.8214,0.5837,0.8528,0.6150
+50,0.7306,0.3994,0.1650,0.0743,0.5664,0.3417,0.3669,0.0850,0.4484,0.5027,0.5577,0.6147,0.8105,0.5634,0.8475,0.5945
+51,0.7406,0.4099,0.1702,0.0758,0.5664,0.3417,0.3669,0.0850,0.4636,0.5214,0.5723,0.6338,0.8109,0.5711,0.8459,0.6127
+52,0.7504,0.4204,0.1756,0.0773,0.5664,0.3417,0.3669,0.0850,0.4641,0.5225,0.5767,0.6442,0.8078,0.5802,0.8430,0.6225
+53,0.7600,0.4311,0.1812,0.0789,0.5664,0.3417,0.3669,0.0850,0.4578,0.5145,0.5698,0.6428,0.7961,0.5728,0.8362,0.6216
+54,0.7693,0.4419,0.1869,0.0807,0.5664,0.3417,0.3669,0.0850,0.4420,0.5000,0.5608,0.6377,0.7973,0.5620,0.8323,0.6159
+55,0.7784,0.4528,0.1928,0.0825,0.6815,0.3752,0.2944,0.0876,0.4284,0.4733,0.5511,0.6372,0.7795,0.5519,0.8241,0.6097
+56,0.7873,0.4637,0.1989,0.0843,0.6815,0.3752,0.2944,0.0876,0.4150,0.4553,0.5417,0.6320,0.7719,0.5384,0.8191,0.6048
+57,0.7959,0.4748,0.2051,0.0863,0.6815,0.3752,0.2944,0.0876,0.4031,0.4447,0.5275,0.6347,0.7736,0.5406,0.8194,0.6030
+58,0.8043,0.4860,0.2116,0.0884,0.6815,0.3752,0.2944,0.0876,0.4017,0.4394,0.5286,0.6353,0.7592,0.5320,0.8161,0.6022
+59,0.8123,0.4972,0.2182,0.0906,0.6815,0.3752,0.2944,0.0876,0.3917,0.4294,0.5178,0.6398,0.7673,0.5306,0.8153,0.6144
+60,0.8201,0.5085,0.2250,0.0928,0.7620,0.5266,0.2707,0.0614,0.4025,0.4367,0.5219,0.6555,0.7481,0.5284,0.8078,0.6097
+61,0.8275,0.5198,0.2320,0.0952,0.7620,0.5266,0.2707,0.0614,0.3959,0.4328,0.5194,0.6620,0.7506,0.5339,0.8100,0.6188
+62,0.8346,0.5312,0.2392,0.0977,0.7620,0.5266,0.2707,0.0614,0.3772,0.4113,0.5034,0.6430,0.7334,0.5127,0.8047,0.6066
+63,0.8415,0.5427,0.2466,0.1003,0.7620,0.5266,0.2707,0.0614,0.3656,0.4012,0.4852,0.6445,0.7181,0.5086,0.8092,0.6123
+64,0.8479,0.5541,0.2542,0.1030,0.7620,0.5266,0.2707,0.0614,0.3669,0.4002,0.4944,0.6781,0.7295,0.5186,0.8113,0.6239
+65,0.8541,0.5656,0.2619,0.1059,0.7780,0.5886,0.2782,0.1319,0.3423,0.3628,0.4720,0.6581,0.7077,0.4858,0.7975,0.6044
+66,0.8598,0.5770,0.2699,0.1088,0.7780,0.5886,0.2782,0.1319,0.3559,0.3697,0.4758,0.6737,0.7070,0.5028,0.8017,0.6109
+67,0.8653,0.5884,0.2780,0.1119,0.7780,0.5886,0.2782,0.1319,0.3431,0.3595,0.4656,0.6742,0.6959,0.4964,0.8027,0.6173
+68,0.8703,0.5999,0.2863,0.1151,0.7780,0.5886,0.2782,0.1319,0.3206,0.3348,0.4347,0.6705,0.6795,0.4675,0.7986,0.6094
+69,0.8750,0.6113,0.2948,0.1185,0.7780,0.5886,0.2782,0.1319,0.3141,0.3311,0.4333,0.6734,0.6716,0.4728,0.7978,0.6045
+70,0.8793,0.6226,0.3035,0.1220,0.8152,0.5801,0.3210,0.1262,0.3159,0.3256,0.4283,0.6806,0.6633,0.4614,0.7948,0.6214
+71,0.8832,0.6339,0.3124,0.1256,0.8152,0.5801,0.3210,0.1262,0.3111,0.3172,0.4192,0.6942,0.6588,0.4544,0.7997,0.6178
+72,0.8867,0.6451,0.3214,0.1294,0.8152,0.5801,0.3210,0.1262,0.2930,0.3045,0.3930,0.6834,0.6375,0.4402,0.8002,0.6102
+73,0.8898,0.6562,0.3306,0.1333,0.8152,0.5801,0.3210,0.1262,0.2866,0.2953,0.3877,0.6806,0.6170,0.4252,0.7989,0.5981
+74,0.8925,0.6672,0.3399,0.1373,0.8152,0.5801,0.3210,0.1262,0.2805,0.2858,0.3880,0.6878,0.6180,0.4269,0.7948,0.6006
+75,0.8948,0.6781,0.3495,0.1415,0.8280,0.6911,0.2812,0.1456,0.2850,0.2884,0.3838,0.7037,0.6061,0.4295,0.8063,0.6092
+76,0.8966,0.6889,0.3592,0.1459,0.8280,0.6911,0.2812,0.1456,0.2711,0.2786,0.3611,0.6967,0.5878,0.4047,0.7991,0.6066
+77,0.8981,0.6996,0.3690,0.1505,0.8280,0.6911,0.2812,0.1456,0.2692,0.2762,0.3602,0.7033,0.5841,0.4091,0.8008,0.6123
+78,0.8992,0.7101,0.3790,0.1551,0.8280,0.6911,0.2812,0.1456,0.2562,0.2611,0.3381,0.7055,0.5684,0.3895,0.8025,0.6100
+79,0.8998,0.7205,0.3892,0.1600,0.8280,0.6911,0.2812,0.1456,0.2658,0.2734,0.3513,0.7169,0.5609,0.3973,0.8005,0.6106
+80,0.9000,0.7306,0.3994,0.1650,0.8175,0.6832,0.3591,0.1551,0.2517,0.2598,0.3228,0.7125,0.5463,0.3734,0.7998,0.6023
+81,0.8998,0.7406,0.4099,0.1702,0.8175,0.6832,0.3591,0.1551,0.2448,0.2556,0.3212,0.7169,0.5433,0.3734,0.7989,0.6078
+82,0.8992,0.7504,0.4204,0.1756,0.8175,0.6832,0.3591,0.1551,0.2550,0.2608,0.3203,0.7284,0.5334,0.3731,0.8083,0.6119
+83,0.8981,0.7600,0.4311,0.1812,0.8175,0.6832,0.3591,0.1551,0.2270,0.2344,0.2856,0.7184,0.5056,0.3438,0.7997,0.6087
+84,0.8966,0.7693,0.4419,0.1869,0.8175,0.6832,0.3591,0.1551,0.2228,0.2322,0.2875,0.7209,0.5028,0.3439,0.8033,0.6133
+85,0.8948,0.7784,0.4528,0.1928,0.7546,0.7632,0.5098,0.1086,0.2263,0.2333,0.2809,0.7312,0.4891,0.3481,0.8028,0.6170
+86,0.8925,0.7873,0.4637,0.1989,0.7546,0.7632,0.5098,0.1086,0.2180,0.2275,0.2772,0.7378,0.4770,0.3352,0.8047,0.6158
+87,0.8898,0.7959,0.4748,0.2051,0.7546,0.7632,0.5098,0.1086,0.2167,0.2244,0.2711,0.7444,0.4778,0.3331,0.8100,0.6205
+88,0.8867,0.8043,0.4860,0.2116,0.7546,0.7632,0.5098,0.1086,0.2077,0.2128,0.2555,0.7414,0.4595,0.3242,0.8072,0.6209
+89,0.8832,0.8123,0.4972,0.2182,0.7546,0.7632,0.5098,0.1086,0.1977,0.2070,0.2437,0.7470,0.4389,0.3145,0.8105,0.5988
+90,0.8793,0.8201,0.5085,0.2250,0.8132,0.8193,0.4518,0.1791,0.1758,0.1816,0.2305,0.7377,0.4353,0.2975,0.8144,0.6045
+91,0.8750,0.8275,0.5198,0.2320,0.8132,0.8193,0.4518,0.1791,0.1733,0.1791,0.2181,0.7420,0.4148,0.2867,0.8156,0.6100
+92,0.8703,0.8346,0.5312,0.2392,0.8132,0.8193,0.4518,0.1791,0.1720,0.1777,0.2272,0.7539,0.4261,0.3005,0.8214,0.6180
+93,0.8653,0.8415,0.5427,0.2466,0.8132,0.8193,0.4518,0.1791,0.1623,0.1708,0.2125,0.7552,0.4000,0.2787,0.8219,0.6170
+94,0.8598,0.8479,0.5541,0.2542,0.8132,0.8193,0.4518,0.1791,0.1636,0.1705,0.2070,0.7620,0.3958,0.2834,0.8267,0.6202
+95,0.8541,0.8541,0.5656,0.2619,0.8405,0.8585,0.5082,0.1960,0.1519,0.1597,0.1958,0.7583,0.3752,0.2661,0.8252,0.6100
+96,0.8479,0.8598,0.5770,0.2699,0.8405,0.8585,0.5082,0.1960,0.1423,0.1447,0.1839,0.7575,0.3669,0.2577,0.8289,0.6159
+97,0.8415,0.8653,0.5884,0.2780,0.8405,0.8585,0.5082,0.1960,0.1497,0.1544,0.1891,0.7697,0.3663,0.2689,0.8350,0.6209
+98,0.8346,0.8703,0.5999,0.2863,0.8405,0.8585,0.5082,0.1960,0.1359,0.1419,0.1742,0.7605,0.3372,0.2411,0.8309,0.6025
+99,0.8275,0.8750,0.6113,0.2948,0.8405,0.8585,0.5082,0.1960,0.1331,0.1400,0.1714,0.7672,0.3372,0.2434,0.8434,0.6098
+100,0.8201,0.8793,0.6226,0.3035,0.8453,0.8563,0.5480,0.2668,0.1228,0.1212,0.1511,0.7609,0.3120,0.2172,0.8416,0.6038
+101,0.8123,0.8832,0.6339,0.3124,0.8453,0.8563,0.5480,0.2668,0.1275,0.1300,0.1583,0.7595,0.3139,0.2258,0.8395,0.6030
+102,0.8043,0.8867,0.6451,0.3214,0.8453,0.8563,0.5480,0.2668,0.1259,0.1256,0.1517,0.7677,0.3056,0.2205,0.8581,0.6172
+103,0.7959,0.8898,0.6562,0.3306,0.8453,0.8563,0.5480,0.2668,0.1328,0.1311,0.1592,0.7720,0.3153,0.2337,0.8556,0.6191
+104,0.7873,0.8925,0.6672,0.3399,0.8453,0.8563,0.5480,0.2668,0.1173,0.1169,0.1405,0.7703,0.2888,0.2075,0.8602,0.6172
+105,0.7784,0.8948,0.6781,0.3495,0.7990,0.8844,0.6222,0.2857,0.1198,0.1186,0.1377,0.7706,0.2812,0.2039,0.8589,0.6045
+106,0.7693,0.8966,0.6889,0.3592,0.7990,0.8844,0.6222,0.2857,0.1055,0.1045,0.1231,0.7655,0.2698,0.1933,0.8702,0.6097
+107,0.7600,0.8981,0.6996,0.3690,0.7990,0.8844,0.6222,0.2857,0.1133,0.1130,0.1330,0.7745,0.2722,0.2048,0.8752,0.6180
+108,0.7504,0.8992,0.7101,0.3790,0.7990,0.8844,0.6222,0.2857,0.0983,0.1000,0.1108,0.7653,0.2562,0.1861,0.8809,0.5988
+109,0.7406,0.8998,0.7205,0.3892,0.7990,0.8844,0.6222,0.2857,0.1014,0.0989,0.1197,0.7642,0.2487,0.1875,0.8803,0.6081
+110,0.7306,0.9000,0.7306,0.3994,0.6546,0.9041,0.5924,0.3644,0.0964,0.0952,0.1086,0.7709,0.2441,0.1841,0.8855,0.6081
+111,0.7205,0.8998,0.7406,0.4099,0.6546,0.9041,0.5924,0.3644,0.0986,0.0964,0.1122,0.7766,0.2450,0.1889,0.8973,0.6173
+112,0.7101,0.8992,0.7504,0.4204,0.6546,0.9041,0.5924,0.3644,0.0880,0.0872,0.0978,0.7739,0.2331,0.1766,0.9114,0.6088
+113,0.6996,0.8981,0.7600,0.4311,0.6546,0.9041,0.5924,0.3644,0.0817,0.0783,0.0873,0.7783,0.2133,0.1613,0.9067,0.6089
+114,0.6889,0.8966,0.7693,0.4419,0.6546,0.9041,0.5924,0.3644,0.0822,0.0838,0.0880,0.7781,0.2191,0.1664,0.9194,0.6012
+115,0.6781,0.8948,0.7784,0.4528,0.6431,0.9179,0.6429,0.3728,0.0777,0.0778,0.0820,0.7820,0.2239,0.1752,0.9200,0.6120
+116,0.6672,0.8925,0.7873,0.4637,0.6431,0.9179,0.6429,0.3728,0.0731,0.0764,0.0808,0.7739,0.2134,0.1694,0.9278,0.6056
+117,0.6562,0.8898,0.7959,0.4748,0.6431,0.9179,0.6429,0.3728,0.0642,0.0656,0.0652,0.7792,0.2086,0.1677,0.9341,0.6159
+118,0.6451,0.8867,0.8043,0.4860,0.6431,0.9179,0.6429,0.3728,0.0561,0.0602,0.0603,0.7816,0.1995,0.1584,0.9478,0.6147
+119,0.6339,0.8832,0.8123,0.4972,0.6431,0.9179,0.6429,0.3728,0.0533,0.0573,0.0559,0.7816,0.1975,0.1600,0.9520,0.6120
+120,0.6226,0.8793,0.8201,0.5085,0.5566,0.9275,0.7016,0.4034,0.0480,0.0509,0.0550,0.7833,0.1966,0.1541,0.9569,0.6092
+121,0.6113,0.8750,0.8275,0.5198,0.5566,0.9275,0.7016,0.4034,0.0383,0.0436,0.0458,0.7733,0.1966,0.1602,0.9630,0.6020
+122,0.5999,0.8703,0.8346,0.5312,0.5566,0.9275,0.7016,0.4034,0.0353,0.0400,0.0447,0.7839,0.1888,0.1530,0.9697,0.6166
+123,0.5884,0.8653,0.8415,0.5427,0.5566,0.9275,0.7016,0.4034,0.0328,0.0369,0.0425,0.7770,0.1881,0.1487,0.9717,0.6044
+124,0.5770,0.8598,0.8479,0.5541,0.5566,0.9275,0.7016,0.4034,0.0319,0.0366,0.0419,0.7825,0.1866,0.1561,0.9823,0.6164
+125,0.5656,0.8541,0.8541,0.5656,0.5426,0.9342,0.7029,0.4248,0.0303,0.0322,0.0409,0.7817,0.1777,0.1481,0.9866,0.6102
+126,0.5541,0.8479,0.8598,0.5770,0.5426,0.9342,0.7029,0.4248,0.0294,0.0302,0.0380,0.7758,0.1748,0.1436,0.9912,0.6072
+127,0.5427,0.8415,0.8653,0.5884,0.5426,0.9342,0.7029,0.4248,0.0295,0.0294,0.0386,0.7734,0.1728,0.1445,0.9947,0.5983
+128,0.5312,0.8346,0.8703,0.5999,0.5426,0.9342,0.7029,0.4248,0.0414,0.0434,0.0517,0.7739,0.1909,0.1572,0.9953,0.6108
+129,0.5198,0.8275,0.8750,0.6113,0.5426,0.9342,0.7029,0.4248,0.0433,0.0433,0.0534,0.7909,0.1986,0.1658,0.9973,0.6273
+130,0.5085,0.8201,0.8793,0.6226,0.5356,0.9157,0.7063,0.5244,0.0458,0.0464,0.0528,0.7773,0.1791,0.1469,0.9991,0.6067
+131,0.4972,0.8123,0.8832,0.6339,0.5356,0.9157,0.7063,0.5244,0.0481,0.0500,0.0550,0.7780,0.1855,0.1517,0.9992,0.6070
+132,0.4860,0.8043,0.8867,0.6451,0.5356,0.9157,0.7063,0.5244,0.0592,0.0642,0.0641,0.7716,0.1980,0.1597,0.9997,0.6048
+133,0.4748,0.7959,0.8898,0.6562,0.5356,0.9157,0.7063,0.5244,0.0642,0.0700,0.0653,0.7758,0.2031,0.1625,0.9998,0.6064
+134,0.4637,0.7873,0.8925,0.6672,0.5356,0.9157,0.7063,0.5244,0.0731,0.0845,0.0788,0.7803,0.2075,0.1613,0.9998,0.6131
+135,0.4528,0.7784,0.8948,0.6781,0.5315,0.9260,0.7151,0.6520,0.0722,0.0803,0.0733,0.7822,0.2139,0.1641,0.9994,0.6095
+136,0.4419,0.7693,0.8966,0.6889,0.5315,0.9260,0.7151,0.6520,0.0806,0.0900,0.0863,0.7748,0.2262,0.1794,0.9998,0.6069
+137,0.4311,0.7600,0.8981,0.6996,0.5315,0.9260,0.7151,0.6520,0.0856,0.0958,0.0908,0.7723,0.2284,0.1759,0.9997,0.6114
+138,0.4204,0.7504,0.8992,0.7101,0.5315,0.9260,0.7151,0.6520,0.0897,0.1022,0.0966,0.7694,0.2259,0.1739,1.0000,0.6072
+139,0.4099,0.7406,0.8998,0.7205,0.5315,0.9260,0.7151,0.6520,0.0994,0.1153,0.1070,0.7670,0.2386,0.1781,1.0000,0.6094
+140,0.3994,0.7306,0.9000,0.7306,0.4095,0.8086,0.7856,0.6475,0.1019,0.1095,0.1080,0.7816,0.2458,0.1844,1.0000,0.6025
+141,0.3892,0.7205,0.8998,0.7406,0.4095,0.8086,0.7856,0.6475,0.1017,0.1134,0.1113,0.7619,0.2514,0.1877,1.0000,0.6055
+142,0.3790,0.7101,0.8992,0.7504,0.4095,0.8086,0.7856,0.6475,0.1022,0.1142,0.1155,0.7670,0.2623,0.1925,1.0000,0.6173
+143,0.3690,0.6996,0.8981,0.7600,0.4095,0.8086,0.7856,0.6475,0.1095,0.1233,0.1234,0.7730,0.2714,0.1948,0.9998,0.6002
+144,0.3592,0.6889,0.8966,0.7693,0.4095,0.8086,0.7856,0.6475,0.1128,0.1269,0.1298,0.7759,0.2842,0.2064,0.9998,0.6119
+145,0.3495,0.6781,0.8948,0.7784,0.3668,0.7617,0.8349,0.6377,0.1142,0.1275,0.1344,0.7666,0.2777,0.1997,0.9997,0.6119
+146,0.3399,0.6672,0.8925,0.7873,0.3668,0.7617,0.8349,0.6377,0.1119,0.1244,0.1305,0.7595,0.2836,0.2012,0.9998,0.6047
+147,0.3306,0.6562,0.8898,0.7959,0.3668,0.7617,0.8349,0.6377,0.1175,0.1325,0.1419,0.7700,0.2923,0.2134,0.9995,0.6122
+148,0.3214,0.6451,0.8867,0.8043,0.3668,0.7617,0.8349,0.6377,0.1198,0.1367,0.1473,0.7512,0.3027,0.2114,0.9994,0.6053
+149,0.3124,0.6339,0.8832,0.8123,0.3668,0.7617,0.8349,0.6377,0.1203,0.1414,0.1509,0.7628,0.3097,0.2175,0.9988,0.6119
+150,0.3035,0.6226,0.8793,0.8201,0.4112,0.6657,0.7920,0.7314,0.1303,0.1489,0.1600,0.7612,0.3248,0.2303,0.9984,0.6103
+151,0.2948,0.6113,0.8750,0.8275,0.4112,0.6657,0.7920,0.7314,0.1336,0.1511,0.1636,0.7675,0.3395,0.2434,0.9986,0.6181
+152,0.2863,0.5999,0.8703,0.8346,0.4112,0.6657,0.7920,0.7314,0.1314,0.1500,0.1669,0.7586,0.3419,0.2395,0.9988,0.6130
+153,0.2780,0.5884,0.8653,0.8415,0.4112,0.6657,0.7920,0.7314,0.1389,0.1628,0.1792,0.7602,0.3600,0.2533,0.9980,0.6064
+154,0.2699,0.5770,0.8598,0.8479,0.4112,0.6657,0.7920,0.7314,0.1455,0.1670,0.1803,0.7602,0.3666,0.2539,0.9967,0.6109
+155,0.2619,0.5656,0.8541,0.8541,0.4023,0.6487,0.7279,0.7909,0.1444,0.1561,0.1864,0.7567,0.3900,0.2736,0.9967,0.6184
+156,0.2542,0.5541,0.8479,0.8598,0.4023,0.6487,0.7279,0.7909,0.1544,0.1683,0.1930,0.7462,0.3825,0.2703,0.9967,0.6023
+157,0.2466,0.5427,0.8415,0.8653,0.4023,0.6487,0.7279,0.7909,0.1561,0.1731,0.2031,0.7436,0.3978,0.2725,0.9961,0.5998
+158,0.2392,0.5312,0.8346,0.8703,0.4023,0.6487,0.7279,0.7909,0.1666,0.1856,0.2117,0.7436,0.3997,0.2844,0.9964,0.5995
+159,0.2320,0.5198,0.8275,0.8750,0.4023,0.6487,0.7279,0.7909,0.1833,0.2002,0.2272,0.7475,0.4266,0.3025,0.9970,0.6202
+160,0.2250,0.5085,0.8201,0.8793,0.3996,0.7391,0.6317,0.8021,0.1950,0.2144,0.2455,0.7559,0.4427,0.3178,0.9945,0.6152
+161,0.2182,0.4972,0.8123,0.8832,0.3996,0.7391,0.6317,0.8021,0.1914,0.2119,0.2384,0.7483,0.4483,0.3091,0.9933,0.6070
+162,0.2116,0.4860,0.8043,0.8867,0.3996,0.7391,0.6317,0.8021,0.2041,0.2273,0.2481,0.7394,0.4559,0.3205,0.9925,0.6189
+163,0.2051,0.4748,0.7959,0.8898,0.3996,0.7391,0.6317,0.8021,0.2064,0.2313,0.2519,0.7356,0.4667,0.3200,0.9944,0.6089
+164,0.1989,0.4637,0.7873,0.8925,0.3996,0.7391,0.6317,0.8021,0.2105,0.2370,0.2587,0.7178,0.4736,0.3278,0.9931,0.5963
+165,0.1928,0.4528,0.7784,0.8948,0.4074,0.6052,0.6518,0.8465,0.2225,0.2411,0.2802,0.7383,0.4942,0.3445,0.9923,0.6205
+166,0.1869,0.4419,0.7693,0.8966,0.4074,0.6052,0.6518,0.8465,0.2337,0.2578,0.2962,0.7292,0.4977,0.3522,0.9908,0.6125
+167,0.1812,0.4311,0.7600,0.8981,0.4074,0.6052,0.6518,0.8465,0.2188,0.2464,0.2772,0.7145,0.4944,0.3347,0.9902,0.5953
+168,0.1756,0.4204,0.7504,0.8992,0.4074,0.6052,0.6518,0.8465,0.2425,0.2695,0.3036,0.7144,0.5233,0.3644,0.9897,0.6073
+169,0.1702,0.4099,0.7406,0.8998,0.4074,0.6052,0.6518,0.8465,0.2522,0.2827,0.3130,0.7269,0.5300,0.3769,0.9898,0.6197
+170,0.1650,0.3994,0.7306,0.9000,0.3610,0.5848,0.7045,0.8047,0.2555,0.2855,0.3164,0.7114,0.5473,0.3731,0.9900,0.6013
+171,0.1600,0.3892,0.7205,0.8998,0.3610,0.5848,0.7045,0.8047,0.2678,0.2989,0.3339,0.7116,0.5625,0.3881,0.9887,0.6130
+172,0.1551,0.3790,0.7101,0.8992,0.3610,0.5848,0.7045,0.8047,0.2567,0.2941,0.3345,0.6994,0.5622,0.3795,0.9881,0.6139
+173,0.1505,0.3690,0.6996,0.8981,0.3610,0.5848,0.7045,0.8047,0.2687,0.3083,0.3483,0.7055,0.5852,0.4097,0.9866,0.6177
+174,0.1459,0.3592,0.6889,0.8966,0.3610,0.5848,0.7045,0.8047,0.2745,0.3125,0.3511,0.6942,0.5920,0.4102,0.9844,0.6072
+175,0.1415,0.3495,0.6781,0.8948,0.3609,0.5077,0.7782,0.6686,0.2787,0.3044,0.3628,0.6955,0.6058,0.4130,0.9848,0.6083
+176,0.1373,0.3399,0.6672,0.8925,0.3609,0.5077,0.7782,0.6686,0.2905,0.3195,0.3769,0.6866,0.6252,0.4309,0.9856,0.6156
+177,0.1333,0.3306,0.6562,0.8898,0.3609,0.5077,0.7782,0.6686,0.3072,0.3339,0.3930,0.6944,0.6361,0.4478,0.9870,0.6170
+178,0.1294,0.3214,0.6451,0.8867,0.3609,0.5077,0.7782,0.6686,0.3008,0.3341,0.4025,0.6878,0.6455,0.4503,0.9850,0.6223
+179,0.1256,0.3124,0.6339,0.8832,0.3609,0.5077,0.7782,0.6686,0.3078,0.3428,0.4114,0.6842,0.6467,0.4545,0.9833,0.6145
+180,0.1220,0.3035,0.6226,0.8793,0.2830,0.4513,0.6974,0.7530,0.3212,0.3528,0.4223,0.6783,0.6580,0.4555,0.9817,0.6088
+181,0.1185,0.2948,0.6113,0.8750,0.2830,0.4513,0.6974,0.7530,0.3152,0.3542,0.4234,0.6670,0.6728,0.4616,0.9831,0.6111
+182,0.1151,0.2863,0.5999,0.8703,0.2830,0.4513,0.6974,0.7530,0.3269,0.3689,0.4327,0.6723,0.6731,0.4773,0.9816,0.6137
+183,0.1119,0.2780,0.5884,0.8653,0.2830,0.4513,0.6974,0.7530,0.3366,0.3786,0.4489,0.6630,0.6878,0.4841,0.9800,0.6108
+184,0.1088,0.2699,0.5770,0.8598,0.2830,0.4513,0.6974,0.7530,0.3345,0.3830,0.4481,0.6591,0.7108,0.4878,0.9794,0.6075
+185,0.1059,0.2619,0.5656,0.8541,0.2283,0.4507,0.6742,0.7489,0.3503,0.3883,0.4627,0.6581,0.7131,0.4953,0.9811,0.6108
+186,0.1030,0.2542,0.5541,0.8479,0.2283,0.4507,0.6742,0.7489,0.3666,0.4020,0.4778,0.6595,0.7230,0.5069,0.9783,0.6095
+187,0.1003,0.2466,0.5427,0.8415,0.2283,0.4507,0.6742,0.7489,0.3625,0.4083,0.4831,0.6517,0.7219,0.5097,0.9783,0.6100
+188,0.0977,0.2392,0.5312,0.8346,0.2283,0.4507,0.6742,0.7489,0.3839,0.4247,0.4997,0.6630,0.7366,0.5247,0.9792,0.6103
+189,0.0952,0.2320,0.5198,0.8275,0.2283,0.4507,0.6742,0.7489,0.3759,0.4217,0.5020,0.6500,0.7409,0.5208,0.9769,0.6033
+190,0.0928,0.2250,0.5085,0.8201,0.2204,0.5558,0.7569,0.6387,0.3842,0.4609,0.5042,0.6461,0.7492,0.5255,0.9750,0.6073
+191,0.0906,0.2182,0.4972,0.8123,0.2204,0.5558,0.7569,0.6387,0.4127,0.4914,0.5231,0.6519,0.7656,0.5423,0.9747,0.6150
+192,0.0884,0.2116,0.4860,0.8043,0.2204,0.5558,0.7569,0.6387,0.4161,0.4811,0.5283,0.6395,0.7642,0.5358,0.9756,0.6044
+193,0.0863,0.2051,0.4748,0.7959,0.2204,0.5558,0.7569,0.6387,0.4188,0.4950,0.5341,0.6416,0.7775,0.5483,0.9730,0.6034
+194,0.0843,0.1989,0.4637,0.7873,0.2204,0.5558,0.7569,0.6387,0.4298,0.5053,0.5348,0.6389,0.7789,0.5520,0.9681,0.6080
+195,0.0825,0.1928,0.4528,0.7784,0.1563,0.3891,0.7076,0.5657,0.4384,0.4919,0.5558,0.6420,0.7900,0.5616,0.9730,0.6128
+196,0.0807,0.1869,0.4419,0.7693,0.1563,0.3891,0.7076,0.5657,0.4398,0.4961,0.5511,0.6342,0.7902,0.5597,0.9680,0.6103
+197,0.0789,0.1812,0.4311,0.7600,0.1563,0.3891,0.7076,0.5657,0.4366,0.4956,0.5480,0.6264,0.7941,0.5558,0.9714,0.6095
+198,0.0773,0.1756,0.4204,0.7504,0.1563,0.3891,0.7076,0.5657,0.4583,0.5166,0.5692,0.6366,0.8066,0.5755,0.9681,0.6161
+199,0.0758,0.1702,0.4099,0.7406,0.1563,0.3891,0.7076,0.5657,0.4570,0.5278,0.5742,0.6353,0.8100,0.5761,0.9677,0.6130
+200,0.0743,0.1650,0.3994,0.7306,0.1094,0.3187,0.5844,0.6810,0.4683,0.5158,0.5716,0.6322,0.8214,0.5753,0.9692,0.6178
+201,0.0729,0.1600,0.3892,0.7205,0.1094,0.3187,0.5844,0.6810,0.4617,0.5113,0.5602,0.6206,0.8131,0.5678,0.9644,0.6091
+202,0.0715,0.1551,0.3790,0.7101,0.1094,0.3187,0.5844,0.6810,0.4773,0.5277,0.5750,0.6303,0.8192,0.5848,0.9680,0.6095
+203,0.0703,0.1505,0.3690,0.6996,0.1094,0.3187,0.5844,0.6810,0.4764,0.5306,0.5727,0.6166,0.8142,0.5716,0.9644,0.6064
+204,0.0691,0.1459,0.3592,0.6889,0.1094,0.3187,0.5844,0.6810,0.4811,0.5361,0.5730,0.6220,0.8284,0.5828,0.9620,0.6141
+205,0.0679,0.1415,0.3495,0.6781,0.1171,0.2396,0.4780,0.7617,0.4900,0.5477,0.5775,0.6222,0.8348,0.5856,0.9691,0.6062
+206,0.0669,0.1373,0.3399,0.6672,0.1171,0.2396,0.4780,0.7617,0.5064,0.5620,0.5867,0.6256,0.8397,0.5923,0.9647,0.6081
+207,0.0658,0.1333,0.3306,0.6562,0.1171,0.2396,0.4780,0.7617,0.5139,0.5695,0.5898,0.6269,0.8344,0.5970,0.9622,0.6255
+208,0.0649,0.1294,0.3214,0.6451,0.1171,0.2396,0.4780,0.7617,0.5095,0.5716,0.5894,0.6256,0.8419,0.5934,0.9611,0.6200
+209,0.0640,0.1256,0.3124,0.6339,0.1171,0.2396,0.4780,0.7617,0.5125,0.5802,0.5948,0.6253,0.8308,0.5989,0.9616,0.6173
+210,0.0631,0.1220,0.3035,0.6226,0.0820,0.1677,0.4851,0.6187,0.5186,0.5709,0.5964,0.6256,0.8497,0.6052,0.9650,0.6172
+211,0.0623,0.1185,0.2948,0.6113,0.0820,0.1677,0.4851,0.6187,0.5139,0.5714,0.5814,0.6136,0.8414,0.5906,0.9580,0.6053
+212,0.0615,0.1151,0.2863,0.5999,0.0820,0.1677,0.4851,0.6187,0.5234,0.5822,0.5911,0.6158,0.8494,0.6025,0.9580,0.6114
+213,0.0608,0.1119,0.2780,0.5884,0.0820,0.1677,0.4851,0.6187,0.5212,0.5762,0.5894,0.6087,0.8491,0.5912,0.9531,0.6006
+214,0.0601,0.1088,0.2699,0.5770,0.0820,0.1677,0.4851,0.6187,0.5287,0.5892,0.5919,0.6122,0.8447,0.5988,0.9559,0.6109
+215,0.0594,0.1059,0.2619,0.5656,0.2902,0.1174,0.3395,0.6966,0.5250,0.5744,0.5919,0.6142,0.8552,0.5998,0.9573,0.6042
+216,0.0588,0.1030,0.2542,0.5541,0.2902,0.1174,0.3395,0.6966,0.5273,0.5772,0.5892,0.6145,0.8583,0.6022,0.9544,0.6106
+217,0.0583,0.1003,0.2466,0.5427,0.2902,0.1174,0.3395,0.6966,0.5300,0.5817,0.5861,0.6089,0.8511,0.6016,0.9534,0.6055
+218,0.0577,0.0977,0.2392,0.5312,0.2902,0.1174,0.3395,0.6966,0.5300,0.5834,0.5861,0.6086,0.8586,0.5977,0.9542,0.6047
+219,0.0572,0.0952,0.2320,0.5198,0.2902,0.1174,0.3395,0.6966,0.5170,0.5759,0.5747,0.5941,0.8530,0.5834,0.9552,0.5950
+220,0.0567,0.0928,0.2250,0.5085,0.2299,0.0822,0.3265,0.7726,0.5405,0.5991,0.5941,0.6177,0.8627,0.6083,0.9528,0.6183
+221,0.0563,0.0906,0.2182,0.4972,0.2299,0.0822,0.3265,0.7726,0.5250,0.5852,0.5806,0.6005,0.8661,0.5927,0.9475,0.5989
+222,0.0559,0.0884,0.2116,0.4860,0.2299,0.0822,0.3265,0.7726,0.5413,0.5958,0.5953,0.6120,0.8603,0.6048,0.9475,0.6062
+223,0.0555,0.0863,0.2051,0.4748,0.2299,0.0822,0.3265,0.7726,0.5408,0.6081,0.5934,0.6198,0.8642,0.6109,0.9497,0.6173
+224,0.0551,0.0843,0.1989,0.4637,0.2299,0.0822,0.3265,0.7726,0.5463,0.6025,0.5925,0.6119,0.8594,0.6048,0.9477,0.6167
+225,0.0547,0.0825,0.1928,0.4528,0.2324,0.1137,0.2285,0.5778,0.5242,0.5775,0.5778,0.6013,0.8611,0.5997,0.9495,0.6041
+226,0.0544,0.0807,0.1869,0.4419,0.2324,0.1137,0.2285,0.5778,0.5298,0.5759,0.5870,0.6044,0.8592,0.5995,0.9464,0.6095
+227,0.0541,0.0789,0.1812,0.4311,0.2324,0.1137,0.2285,0.5778,0.5370,0.5831,0.5872,0.6139,0.8667,0.6098,0.9456,0.6039
+228,0.0538,0.0773,0.1756,0.4204,0.2324,0.1137,0.2285,0.5778,0.5262,0.5827,0.5856,0.6052,0.8687,0.5986,0.9478,0.6109
+229,0.0535,0.0758,0.1702,0.4099,0.2324,0.1137,0.2285,0.5778,0.5348,0.5909,0.5902,0.6106,0.8703,0.6100,0.9389,0.6080
+230,0.0533,0.0743,0.1650,0.3994,0.1667,0.3646,0.2060,0.6158,0.5333,0.5683,0.5856,0.6083,0.8689,0.6050,0.9448,0.6006
+231,0.0531,0.0729,0.1600,0.3892,0.1667,0.3646,0.2060,0.6158,0.5364,0.5747,0.5925,0.6194,0.8692,0.6159,0.9441,0.6055
+232,0.0528,0.0715,0.1551,0.3790,0.1667,0.3646,0.2060,0.6158,0.5302,0.5672,0.5841,0.6092,0.8659,0.6056,0.9387,0.6039
+233,0.0526,0.0703,0.1505,0.3690,0.1667,0.3646,0.2060,0.6158,0.5287,0.5711,0.5822,0.6031,0.8681,0.6025,0.9406,0.6092
+234,0.0524,0.0691,0.1459,0.3592,0.1667,0.3646,0.2060,0.6158,0.5314,0.5684,0.5831,0.6077,0.8689,0.6078,0.9392,0.6175
+235,0.0523,0.0679,0.1415,0.3495,0.1167,0.4464,0.2372,0.4986,0.5280,0.5591,0.5814,0.6070,0.8725,0.6047,0.9408,0.6117
+236,0.0521,0.0669,0.1373,0.3399,0.1167,0.4464,0.2372,0.4986,0.5278,0.5594,0.5803,0.6111,0.8675,0.6105,0.9364,0.6059
+237,0.0519,0.0658,0.1333,0.3306,0.1167,0.4464,0.2372,0.4986,0.5233,0.5508,0.5745,0.5973,0.8630,0.5967,0.9389,0.5955
+238,0.0518,0.0649,0.1294,0.3214,0.1167,0.4464,0.2372,0.4986,0.5361,0.5722,0.5936,0.6155,0.8686,0.6133,0.9463,0.6055
+239,0.0517,0.0640,0.1256,0.3124,0.1167,0.4464,0.2372,0.4986,0.5198,0.5587,0.5792,0.6069,0.8684,0.6044,0.9344,0.6045
+240,0.0515,0.0631,0.1220,0.3035,0.0817,0.3125,0.3079,0.4391,0.5331,0.5697,0.5847,0.6114,0.8738,0.6095,0.9377,0.6072
+241,0.0514,0.0623,0.1185,0.2948,0.0817,0.3125,0.3079,0.4391,0.5314,0.5775,0.5905,0.6147,0.8747,0.6150,0.9306,0.6094
+242,0.0513,0.0615,0.1151,0.2863,0.0817,0.3125,0.3079,0.4391,0.5239,0.5653,0.5811,0.6022,0.8739,0.6014,0.9369,0.6103
+243,0.0512,0.0608,0.1119,0.2780,0.0817,0.3125,0.3079,0.4391,0.5141,0.5578,0.5750,0.6044,0.8664,0.6030,0.9350,0.6005
+244,0.0511,0.0601,0.1088,0.2699,0.0817,0.3125,0.3079,0.4391,0.5336,0.5787,0.5908,0.6170,0.8708,0.6153,0.9400,0.6147
+245,0.0510,0.0594,0.1059,0.2619,0.0572,0.2427,0.2155,0.4626,0.5261,0.5653,0.5867,0.6136,0.8744,0.6136,0.9350,0.6130
+246,0.0509,0.0588,0.1030,0.2542,0.0572,0.2427,0.2155,0.4626,0.5277,0.5666,0.5872,0.6164,0.8763,0.6166,0.9308,0.6141
+247,0.0509,0.0583,0.1003,0.2466,0.0572,0.2427,0.2155,0.4626,0.5284,0.5664,0.5894,0.6150,0.8739,0.6158,0.9336,0.6194
+248,0.0508,0.0577,0.0977,0.2392,0.0572,0.2427,0.2155,0.4626,0.5122,0.5523,0.5708,0.5997,0.8728,0.5989,0.9363,0.6027
+249,0.0507,0.0572,0.0952,0.2320,0.0572,0.2427,0.2155,0.4626,0.5153,0.5534,0.5798,0.6058,0.8739,0.6048,0.9336,0.6013
+250,0.0507,0.0567,0.0928,0.2250,0.0400,0.1699,0.1509,0.3238,0.5344,0.5789,0.5933,0.6208,0.8709,0.6192,0.9339,0.6147
+251,0.0506,0.0563,0.0906,0.2182,0.0400,0.1699,0.1509,0.3238,0.5233,0.5672,0.5817,0.6095,0.8742,0.6091,0.9319,0.6063
+252,0.0506,0.0559,0.0884,0.2116,0.0400,0.1699,0.1509,0.3238,0.5245,0.5664,0.5819,0.6142,0.8759,0.6153,0.9381,0.6058
+253,0.0505,0.0555,0.0863,0.2051,0.0400,0.1699,0.1509,0.3238,0.5248,0.5702,0.5830,0.6095,0.8741,0.6089,0.9334,0.6100
+254,0.0505,0.0551,0.0843,0.1989,0.0400,0.1699,0.1509,0.3238,0.5062,0.5555,0.5708,0.5986,0.8716,0.6003,0.9286,0.6075
+255,0.0504,0.0547,0.0825,0.1928,0.0280,0.1189,0.1897,0.3361,0.5295,0.5695,0.5889,0.6170,0.8780,0.6161,0.9363,0.6152
+256,0.0504,0.0544,0.0807,0.1869,0.0280,0.1189,0.1897,0.3361,0.5173,0.5611,0.5798,0.6066,0.8781,0.6064,0.9302,0.6117
+257,0.0504,0.0541,0.0789,0.1812,0.0280,0.1189,0.1897,0.3361,0.5247,0.5645,0.5830,0.6112,0.8789,0.6106,0.9300,0.6109
+258,0.0503,0.0538,0.0773,0.1756,0.0280,0.1189,0.1897,0.3361,0.5142,0.5581,0.5800,0.6130,0.8770,0.6119,0.9367,0.6070
+259,0.0503,0.0535,0.0758,0.1702,0.0280,0.1189,0.1897,0.3361,0.5133,0.5636,0.5766,0.6056,0.8764,0.6061,0.9344,0.6091
+260,0.0503,0.0533,0.0743,0.1650,0.0200,0.0832,0.1885,0.3339,0.5159,0.5437,0.5758,0.6048,0.8767,0.6050,0.9295,0.6116
+261,0.0503,0.0531,0.0729,0.1600,0.0200,0.0832,0.1885,0.3339,0.5192,0.5442,0.5808,0.6092,0.8764,0.6091,0.9316,0.6056
+262,0.0502,0.0528,0.0715,0.1551,0.0200,0.0832,0.1885,0.3339,0.5186,0.5434,0.5795,0.6073,0.8711,0.6075,0.9261,0.6131
+263,0.0502,0.0526,0.0703,0.1505,0.0200,0.0832,0.1885,0.3339,0.5220,0.5483,0.5903,0.6139,0.8783,0.6136,0.9291,0.6070
+264,0.0502,0.0524,0.0691,0.1459,0.0200,0.0832,0.1885,0.3339,0.5116,0.5403,0.5788,0.6067,0.8739,0.6070,0.9353,0.6114
+265,0.0502,0.0523,0.0679,0.1415,0.0200,0.1684,0.1319,0.5188,0.5198,0.5502,0.5834,0.6122,0.8808,0.6125,0.9284,0.6153
+266,0.0502,0.0521,0.0669,0.1373,0.0200,0.1684,0.1319,0.5188,0.5242,0.5514,0.5813,0.6100,0.8758,0.6094,0.9273,0.6156
+267,0.0502,0.0519,0.0658,0.1333,0.0200,0.1684,0.1319,0.5188,0.5142,0.5427,0.5780,0.6048,0.8742,0.6039,0.9270,0.6123
+268,0.0501,0.0518,0.0649,0.1294,0.0200,0.1684,0.1319,0.5188,0.5255,0.5523,0.5863,0.6150,0.8750,0.6152,0.9270,0.6172
+269,0.0501,0.0517,0.0640,0.1256,0.0200,0.1684,0.1319,0.5188,0.5244,0.5517,0.5894,0.6203,0.8828,0.6216,0.9314,0.6130
+270,0.0501,0.0515,0.0631,0.1220,0.0200,0.3900,0.1138,0.3818,0.5120,0.5425,0.5767,0.6039,0.8664,0.6042,0.9186,0.6020
+271,0.0501,0.0514,0.0623,0.1185,0.0200,0.3900,0.1138,0.3818,0.5250,0.5584,0.5877,0.6178,0.8770,0.6166,0.9294,0.6192
+272,0.0501,0.0513,0.0615,0.1151,0.0200,0.3900,0.1138,0.3818,0.5188,0.5520,0.5833,0.6120,0.8798,0.6120,0.9283,0.6095
+273,0.0501,0.0512,0.0608,0.1119,0.0200,0.3900,0.1138,0.3818,0.5167,0.5528,0.5828,0.6069,0.8756,0.6077,0.9295,0.6061
+274,0.0501,0.0511,0.0601,0.1088,0.0200,0.3900,0.1138,0.3818,0.5109,0.5461,0.5773,0.6073,0.8730,0.6066,0.9323,0.6122
+275,0.0501,0.0510,0.0594,0.1059,0.0545,0.2928,0.0858,0.5523,0.5194,0.5772,0.5867,0.6145,0.8770,0.6144,0.9294,0.6048
+276,0.0501,0.0509,0.0588,0.1030,0.0545,0.2928,0.0858,0.5523,0.5109,0.5653,0.5741,0.6089,0.8748,0.6078,0.9277,0.6078
+277,0.0501,0.0509,0.0583,0.1003,0.0545,0.2928,0.0858,0.5523,0.5123,0.5719,0.5819,0.6105,0.8747,0.6106,0.9273,0.6109
+278,0.0501,0.0508,0.0577,0.0977,0.0545,0.2928,0.0858,0.5523,0.5072,0.5658,0.5738,0.6061,0.8772,0.6064,0.9255,0.6003
+279,0.0500,0.0507,0.0572,0.0952,0.0545,0.2928,0.0858,0.5523,0.5072,0.5684,0.5742,0.6053,0.8781,0.6070,0.9231,0.6066
+280,0.0500,0.0507,0.0567,0.0928,0.0382,0.2502,0.1024,0.6716,0.5273,0.5736,0.5833,0.6128,0.8761,0.6120,0.9313,0.6175
+281,0.0500,0.0506,0.0563,0.0906,0.0382,0.2502,0.1024,0.6716,0.5091,0.5581,0.5716,0.6000,0.8706,0.5991,0.9278,0.6041
+282,0.0500,0.0506,0.0559,0.0884,0.0382,0.2502,0.1024,0.6716,0.5231,0.5761,0.5922,0.6194,0.8803,0.6198,0.9295,0.6234
+283,0.0500,0.0505,0.0555,0.0863,0.0382,0.2502,0.1024,0.6716,0.5228,0.5763,0.5862,0.6162,0.8772,0.6175,0.9275,0.6152
+284,0.0500,0.0505,0.0551,0.0843,0.0382,0.2502,0.1024,0.6716,0.5225,0.5736,0.5861,0.6158,0.8738,0.6159,0.9227,0.6033
+285,0.0500,0.0504,0.0547,0.0825,0.3117,0.2298,0.0717,0.5088,0.5152,0.5762,0.5867,0.6172,0.8780,0.6184,0.9289,0.6166
+286,0.0500,0.0504,0.0544,0.0807,0.3117,0.2298,0.0717,0.5088,0.5277,0.5766,0.5905,0.6214,0.8833,0.6219,0.9323,0.6152
+287,0.0500,0.0504,0.0541,0.0789,0.3117,0.2298,0.0717,0.5088,0.5191,0.5758,0.5900,0.6152,0.8752,0.6153,0.9297,0.6172
+288,0.0500,0.0503,0.0538,0.0773,0.3117,0.2298,0.0717,0.5088,0.5108,0.5709,0.5828,0.6064,0.8723,0.6067,0.9283,0.6017
+289,0.0500,0.0503,0.0535,0.0758,0.3117,0.2298,0.0717,0.5088,0.5114,0.5648,0.5777,0.6120,0.8780,0.6111,0.9305,0.6019
+290,0.0500,0.0503,0.0533,0.0743,0.2182,0.4459,0.0881,0.3906,0.5175,0.5650,0.5817,0.6072,0.8753,0.6066,0.9283,0.6153
+291,0.0500,0.0503,0.0531,0.0729,0.2182,0.4459,0.0881,0.3906,0.5117,0.5597,0.5741,0.6052,0.8777,0.6055,0.9289,0.6158
+292,0.0500,0.0502,0.0528,0.0715,0.2182,0.4459,0.0881,0.3906,0.5220,0.5675,0.5883,0.6145,0.8744,0.6152,0.9286,0.6191
+293,0.0500,0.0502,0.0526,0.0703,0.2182,0.4459,0.0881,0.3906,0.5091,0.5586,0.5772,0.6080,0.8750,0.6080,0.9305,0.6069
+294,0.0500,0.0502,0.0524,0.0691,0.2182,0.4459,0.0881,0.3906,0.5141,0.5645,0.5820,0.6125,0.8797,0.6134,0.9305,0.6167
+295,0.0500,0.0502,0.0523,0.0679,0.2238,0.3809,0.3467,0.3124,0.5167,0.5602,0.5850,0.6092,0.8788,0.6089,0.9250,0.6086
+296,0.0500,0.0502,0.0521,0.0669,0.2238,0.3809,0.3467,0.3124,0.5109,0.5570,0.5734,0.6012,0.8673,0.6009,0.9236,0.6042
+297,0.0500,0.0502,0.0519,0.0658,0.2238,0.3809,0.3467,0.3124,0.5078,0.5536,0.5766,0.6055,0.8766,0.6053,0.9266,0.6197
+298,0.0500,0.0501,0.0518,0.0649,0.2238,0.3809,0.3467,0.3124,0.5158,0.5662,0.5863,0.6148,0.8764,0.6144,0.9283,0.6155
+299,0.0500,0.0501,0.0517,0.0640,0.2238,0.3809,0.3467,0.3124,0.5097,0.5541,0.5745,0.6030,0.8756,0.6030,0.9291,0.6058

data/e4_mismatch.csv

@@ -0,0 +1,34 @@
+snr,delta,cos,ser
+5,-0.2,0.4677884508724716,0.3770625
+5,-0.16,0.47074996654396506,0.3646875
+5,-0.12,0.47221568564297145,0.3585
+5,-0.07999999999999999,0.47274681586669354,0.3546875
+5,-0.03999999999999998,0.4727040260626087,0.3540625
+5,2.7755575615628914e-17,0.4723086101393743,0.3544375
+5,0.040000000000000036,0.4716867416737565,0.3560625
+5,0.08000000000000004,0.4708983022750543,0.358625
+5,0.12000000000000005,0.46995373087844344,0.361125
+5,0.16000000000000006,0.468822335600813,0.3645625
+5,0.20000000000000007,0.4674351413108766,0.367375
+10,-0.2,0.6179798052512585,0.041125
+10,-0.16,0.6187075431561585,0.0384375
+10,-0.12,0.618533082797927,0.0373125
+10,-0.07999999999999999,0.6178185314696448,0.03675
+10,-0.03999999999999998,0.6167856699055824,0.0368125
+10,2.7755575615628914e-17,0.6155644218301132,0.0368125
+10,0.040000000000000036,0.6142165353508265,0.0365625
+10,0.08000000000000004,0.6127386629069682,0.0370625
+10,0.12000000000000005,0.6110461501484961,0.037
+10,0.16000000000000006,0.6089371766429155,0.0379375
+10,0.20000000000000007,0.6060394176785739,0.0390625
+15,-0.2,0.7245091508078058,0.0015625
+15,-0.16,0.7234153240110824,0.0013125
+15,-0.12,0.7218124893564858,0.0011875
+15,-0.07999999999999999,0.7198189738280861,0.0011875
+15,-0.03999999999999998,0.7175246322463084,0.0013125
+15,2.7755575615628914e-17,0.7150128180300644,0.0013125
+15,0.040000000000000036,0.7123604137122186,0.0013125
+15,0.08000000000000004,0.7096065083792866,0.00125
+15,0.12000000000000005,0.7066649657208909,0.0013125
+15,0.16000000000000006,0.7031294678603094,0.0013125
+15,0.20000000000000007,0.6978806195923507,0.0013125

data/e5_learned.csv

@@ -0,0 +1,11 @@
+beta,Learned_cos,Learned_nmse,Learned_ser,LMMSE_cos,LMMSE_nmse,LMMSE_ser,DR_cos,DR_nmse,DR_ser
+0.05,0.25433290948687237,1.4913341816439973,0.93725,0.32438595170361917,0.8747947429055835,0.7435625,0.3540205820656546,0.8534616212824229,0.6781875
+0.1,0.27749199797372404,1.4450160042706301,0.908625,0.33083480253348796,0.8711820802419781,0.735875,0.35888325572780627,0.8530990057430331,0.688125
+0.2,0.3426674810720035,1.3146650373311757,0.77975,0.3631628334523729,0.8517214539022712,0.687125,0.4044853316884553,0.8250654987524828,0.6328125
+0.3,0.4253583486949318,1.1492833027068394,0.5225625,0.41215351640783604,0.8167696498433968,0.586125,0.4725292418961386,0.7698278981975227,0.4156875
+0.4,0.5080146696898473,0.983970660799056,0.271,0.46502203899472316,0.7724895142326921,0.437375,0.5437635339117708,0.7011047805243247,0.149
+0.5,0.5857423053374873,0.8285153890435167,0.1054375,0.5209387168440357,0.7194023005599461,0.2745625,0.6137796870171428,0.6224912193830614,0.0396875
+0.6,0.6587348306034025,0.6825303388352326,0.0335,0.5759702196998538,0.660498042533296,0.142125,0.6823004197629239,0.5355782244821032,0.0096875
+0.7,0.729104895590768,0.5417902090904868,0.009,0.6325766311277184,0.5930092881636482,0.06275,0.7489046160816174,0.44130604465985007,0.0035
+0.8,0.7969874601992837,0.40602507973579044,0.0015,0.690484275571362,0.5179034261312443,0.0218125,0.8148640111384091,0.33923716795658126,0.001
+0.9,0.8588142481772689,0.28237150365486996,0.000625,0.7456249847250824,0.43899344931929274,0.0084375,0.877125382063871,0.23450964925940807,0.0005

data/e5_train_log.csv

@@ -0,0 +1,61 @@
+step,loss
+50,0.588121235370636
+100,0.3500303328037262
+150,0.6307245492935181
+200,0.5117422938346863
+250,0.6843791604042053
+300,0.33192601799964905
+350,0.6433843374252319
+400,0.4546773433685303
+450,0.16626952588558197
+500,0.5854030847549438
+550,0.2317981868982315
+600,0.2849048972129822
+650,0.2996165156364441
+700,0.7279555797576904
+750,0.6565011739730835
+800,0.20011256635189056
+850,0.1910645216703415
+900,0.5921029448509216
+950,0.4238053262233734
+1000,0.6777560710906982
+1050,0.5709654092788696
+1100,0.40542492270469666
+1150,0.38772422075271606
+1200,0.6069692373275757
+1250,0.3610105812549591
+1300,0.15966327488422394
+1350,0.4908602833747864
+1400,0.44641396403312683
+1450,0.64170902967453
+1500,0.42330288887023926
+1550,0.7351509928703308
+1600,0.46302133798599243
+1650,0.16936270892620087
+1700,0.5299801230430603
+1750,0.6421316266059875
+1800,0.6550854444503784
+1850,0.42745232582092285
+1900,0.5026284456253052
+1950,0.3039652407169342
+2000,0.16355615854263306
+2050,0.48246270418167114
+2100,0.34849074482917786
+2150,0.724970817565918
+2200,0.2711065113544464
+2250,0.34548747539520264
+2300,0.5576888918876648
+2350,0.20214445888996124
+2400,0.5585888028144836
+2450,0.41144832968711853
+2500,0.7296308875083923
+2550,0.526506781578064
+2600,0.31999582052230835
+2650,0.22167174518108368
+2700,0.7460469007492065
+2750,0.3096345067024231
+2800,0.21640630066394806
+2850,0.673500120639801
+2900,0.33546051383018494
+2950,0.45799386501312256
+3000,0.1987389326095581

data/e_mask_check.csv

@@ -0,0 +1,9 @@
+d,snr,method,ser_realized,ser_expected,mean_diff,std_diff
+64,10,SR,0.954875,0.8681458333333333,0.08672916666666668,0.0033621798691060795
+64,10,SC,0.47496875,0.29821875,0.17675,0.024687315400153714
+64,10,LMMSE,0.4592604166666667,0.27560416666666665,0.18365625,0.02441695774499421
+64,10,DR,0.07957291666666667,0.04014583333333333,0.039427083333333335,0.008898363955041897
+768,20,SR,0.9959375,0.9498958333333333,0.04604166666666667,0.006360140634364086
+768,20,SC,0.6002083333333333,0.36322916666666666,0.23697916666666666,0.01367125494625696
+768,20,LMMSE,0.5753125,0.33239583333333333,0.24291666666666664,0.011213288867331582
+768,20,DR,0.014895833333333336,0.007395833333333334,0.0075,0.0015728821740147395