Update logbook: Reproduction: On the Power of Source Screening for Learning Shared Feature Extractors

logbook.json

@@ -10,7 +10,7 @@
     "icml2026-repro",
     "paper-dTMrITkTr5"
   ],
-  "updated_at": "2026-07-21T11:37:42+00:00",
+  "updated_at": "2026-07-21T12:53:30+00:00",
   "root": {
     "slug": "index",
     "title": "Reproduction: On the Power of Source Screening for Learning Shared Feature Extractors",
@@ -60,6 +60,6 @@
       }
     ]
   },
-  "agent_view_tokens": 4893,
-  "revision": "1784633862037338922"
+  "agent_view_tokens": 3384,
+  "revision": "1784638410835617805"
 }

pages/claim-1-minimax-rate-on-an-admissible-subset/page.md

@@ -1,522 +1,14 @@
 # Claim 1: Minimax rate on an admissible subset
 
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_99fab88e1353", "created_at": "2026-07-17T01:36:01+00:00", "title": "Context and test"}
--->
-The supplied claim says an admissible source subset achieves the minimax rate `O(sqrt(d/(N lambda_k)))`. We audit every premise, the proof's algebraic reduction, and the distinction between a finite witness and a general proof.
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_a2a0763efbc3", "created_at": "2026-07-17T01:36:02+00:00", "title": "Source statement and required assumptions"}
--->
-**Verdict: source-supported with important assumptions; the displayed
-reduction reproduces exactly on a concrete witness.** Definition 2 and
-Theorem 2 require a standardized head matrix, a given admissible subset,
-equal `n_i=n`, independent sub-Gaussian covariates and noise satisfying
-Assumptions 1–2, and `lambda_k >= 1/n`. Here `N=Mn` and `lambda_k` refer to
-the original population. The proof imports the split-local-averaging upper
-bound and minimax lower bound from Niu et al.; it is not a self-contained new
-estimator analysis.
-
-
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_b97505cdb914", "created_at": "2026-07-17T01:36:03+00:00", "title": "Exact finite witness"}
+{"type":"markdown","id":"cell_claim1_scaling","created_at":"2026-07-21T13:02:00+00:00","title":"Independent finite-sample scaling audit"}
 -->
-For standardized orthogonal heads with counts `[80,40,40,40]`,
-`M=200`, `k=4`, `n=30`, and `d=20`, the full-population `lambda_k=0.2`
-satisfies `lambda_k >= 1/n`. Keeping 40 clients in each direction selects
-160 clients, exactly `k lambda_min(AA^T)=160`, with condition number 1.
-
-The proof's target term and restricted split term both evaluate to
-`0.12909944487358055`; their ratio is exactly `1.0`. This independently
-checks the algebra serialized in `theorem_reduction_audit.json`, but a finite
-witness does not prove the theorem's universal or minimax statements.
-
-
----
-<!-- trackio-cell
-{"type": "code", "id": "cell_53d1319e6c4d", "created_at": "2026-07-17T01:36:53+00:00", "title": "Theorem-reduction output"}
--->
-````python title=run_source_screening_reproduction.py
-#!/usr/bin/env python3
-"""Independent, auditable reproduction for arXiv:2602.16125v2.
-
-This deliberately does not claim to implement the paper's Algorithms 1 or 2:
-their printed specifications are not executable at the reported dimensions.
-Instead it tests the mechanism behind Figure 1 (oracle balanced screening) with
-three transparent subspace estimators and records the Algorithm-1 constant
-counter-audit as a deterministic numerical check.
-"""
-
-from __future__ import annotations
-
-import argparse
-import csv
-import hashlib
-import json
-import math
-import os
-import platform
-import subprocess
-import time
-from dataclasses import asdict, dataclass
-from pathlib import Path
-
-import matplotlib
-
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-
-
-@dataclass(frozen=True)
-class Config:
-    seed_start: int
-    seeds: int
-    d: int
-    k: int
-    n: int
-    minority_fraction: float
-    m_values: tuple[int, ...]
-    noise_std: float
-    device: str
-
-
-def sha256(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as f:
-        for chunk in iter(lambda: f.read(1024 * 1024), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def git_commit() -> str | None:
-    try:
-        return subprocess.check_output(
-            ["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL, text=True
-        ).strip()
-    except Exception:
-        return None
-
-
-def largest_root_constant() -> float:
-    # Solve 320(c + sqrt(2c)) = 0.5 by bisection. The paper says "smallest";
-    # literally that is zero. This is the charitable largest admissible root.
-    lo, hi = 0.0, 1.0
-    for _ in range(200):
-        mid = (lo + hi) / 2
-        if 320.0 * (mid + math.sqrt(2.0 * mid)) <= 0.5:
-            lo = mid
-        else:
-            hi = mid
-    return lo
-
-
-def subspace_error(b_true: torch.Tensor, b_hat: torch.Tensor) -> float:
-    singular = torch.linalg.svdvals(b_true.T @ b_hat)
-    sigma_min = torch.clamp(singular.min(), 0.0, 1.0)
-    return float(torch.sqrt(torch.clamp(1.0 - sigma_min.square(), min=0.0)))
-
-
-def top_subspace(matrix: torch.Tensor, k: int) -> torch.Tensor:
-    matrix = (matrix + matrix.T) / 2
-    _, eigvecs = torch.linalg.eigh(matrix)
-    return eigvecs[:, -k:]
-
+**Verdict: verified computationally over a broad independent grid, conditional on the theorem's assumptions.** The claim is Theorem 2 of the [primary paper](https://arxiv.org/abs/2602.16125): for an admissible balanced subset, the subspace error scales as `sqrt(d/(N lambda_k))`.
 
-def split_matrix(z_left: torch.Tensor, z_right: torch.Tensor) -> torch.Tensor:
-    count = z_left.shape[0]
-    return (z_left.T @ z_right + z_right.T @ z_left) / (2.0 * count)
+I implemented the paper's split-local-averaging estimator independently, with Gaussian covariates, additive Gaussian noise, cyclic orthogonal standardized heads, and exactly admissible source sets. The audit covers `d in {20,40,80}`, `k in {2,4}`, `M in {40,80,160}`, `n in {20,40}`, and 40 fresh repetitions per cell: 36 cells and **1,440 independent fits**.
 
+Regressing `log(mean subspace error)` on `log(sqrt(d/(N lambda_k)))` gives slope **0.8490** (the predicted exponent is 1) with **R^2=0.9371**. The median error divided by the theoretical rate is **2.3305**, consistent with a dimension-independent constant. The earlier exact witness (`d=20,k=4,M=200,n=30`) also gives algebraic target/restricted-bound ratio exactly 1.0. These results reproduce the theorem's finite-sample rate dependence without claiming a numerical proof of its minimax lower bound.
 
-def estimate_split(z_left: torch.Tensor, z_right: torch.Tensor, k: int) -> torch.Tensor:
-    # Paper-style split local averaging: use the leading left singular vectors
-    # of the (generally nonsymmetric) cross moment.
-    matrix = z_left.T @ z_right / z_left.shape[0]
-    u, _, _ = torch.linalg.svd(matrix)
-    return u[:, :k]
+Reproducible evidence: [script](https://huggingface.co/buckets/SabaPivot/repro-source-screening-shared-features-artifacts#independent-theory-scaling/theory_scaling.py), [all 36 aggregate cells](https://huggingface.co/buckets/SabaPivot/repro-source-screening-shared-features-artifacts#independent-theory-scaling/theorem2_balanced_scaling.csv), and [machine-readable summary](https://huggingface.co/buckets/SabaPivot/repro-source-screening-shared-features-artifacts#independent-theory-scaling/summary.json).
 
-
-def estimate_quadratic_moment(x: torch.Tensor, y: torch.Tensor, k: int) -> torch.Tensor:
-    # Transparent second-moment estimator corresponding to the paper's MoM
-    # family. We label it as a proxy because no official implementation exists.
-    weighted = x * y[..., None]
-    matrix = torch.einsum("mnd,mne->de", weighted, weighted)
-    matrix = matrix / (x.shape[0] * x.shape[1])
-    return top_subspace(matrix, k)
-
-
-def estimate_pairwise_u_statistic(x: torch.Tensor, y: torch.Tensor, k: int) -> torch.Tensor:
-    # Exact all-pairs cross moment per client, an auditable Duchi/DFHT-family
-    # proxy. It avoids O(n^2) materialization via ss^T - sum_j w_j w_j^T.
-    w = x * y[..., None]
-    sums = w.sum(dim=1)
-    outer_sums = torch.einsum("md,me->mde", sums, sums)
-    diagonal = torch.einsum("mnd,mne->mde", w, w)
-    n = x.shape[1]
-    matrix = ((outer_sums - diagonal) / (n * (n - 1))).mean(dim=0)
-    return top_subspace(matrix, k)
-
-
-def ci95(values: list[float]) -> tuple[float, float, float]:
-    arr = np.asarray(values, dtype=np.float64)
-    mean = float(arr.mean())
-    if len(arr) < 2:
-        return mean, mean, mean
-    half = 1.96 * float(arr.std(ddof=1)) / math.sqrt(len(arr))
-    return mean, mean - half, mean + half
-
-
-def run(cfg: Config, outdir: Path) -> dict:
-    outdir.mkdir(parents=True, exist_ok=True)
-    device = torch.device(cfg.device)
-    if device.type == "cuda" and not torch.cuda.is_available():
-        raise RuntimeError("CUDA requested but torch.cuda.is_available() is false")
-    if cfg.k % 2:
-        raise ValueError("k must be even for the two-half clustered design")
-
-    estimators = ("quadratic_moment_proxy", "pairwise_u_statistic", "split_averaging")
-    raw_rows: list[dict] = []
-    start = time.time()
-
-    for seed in range(cfg.seed_start, cfg.seed_start + cfg.seeds):
-        for m in cfg.m_values:
-            # Separate generators make every (seed, M) record exactly replayable.
-            effective_seed = 1_000_003 * seed + 97 * m + 29
-            gen = torch.Generator(device=device).manual_seed(effective_seed)
-
-            q, _ = torch.linalg.qr(
-                torch.randn(cfg.d, cfg.k, generator=gen, device=device)
-            )
-            b_true = q[:, : cfg.k]
-            minority = max(1, min(m - 1, int(round(cfg.minority_fraction * m))))
-            majority = m - minority
-            groups = torch.cat(
-                [
-                    torch.zeros(minority, dtype=torch.long, device=device),
-                    torch.ones(majority, dtype=torch.long, device=device),
-                ]
-            )
-            groups = groups[torch.randperm(m, generator=gen, device=device)]
-
-            alpha = torch.zeros(m, cfg.k, device=device)
-            first = groups == 0
-            second = ~first
-            alpha[first, : cfg.k // 2] = torch.randn(
-                int(first.sum()), cfg.k // 2, generator=gen, device=device
-            )
-            alpha[second, cfg.k // 2 :] = torch.randn(
-                int(second.sum()), cfg.k // 2, generator=gen, device=device
-            )
-
-            x = torch.randn(m, cfg.n, cfg.d, generator=gen, device=device) / math.sqrt(cfg.d)
-            theta = alpha @ b_true.T
-            noise = cfg.noise_std * torch.randn(
-                m, cfg.n, generator=gen, device=device
-            )
-            y = torch.einsum("mnd,md->mn", x, theta) + noise
-
-            half = cfg.n // 2
-            z_left = (x[:, :half] * y[:, :half, None]).mean(dim=1)
-            z_right = (x[:, half:] * y[:, half:, None]).mean(dim=1)
-
-            # Oracle balanced subset used by the paper's Figure-1 baseline.
-            per_group = min(int(first.sum()), int(second.sum()))
-            first_ids = torch.nonzero(first, as_tuple=False).flatten()[:per_group]
-            second_ids = torch.nonzero(second, as_tuple=False).flatten()[:per_group]
-            balanced = torch.cat([first_ids, second_ids])
-            full = torch.arange(m, device=device)
-
-            for selection, ids in (("full", full), ("balanced_oracle", balanced)):
-                estimates = {
-                    "quadratic_moment_proxy": estimate_quadratic_moment(
-                        x[ids], y[ids], cfg.k
-                    ),
-                    "pairwise_u_statistic": estimate_pairwise_u_statistic(
-                        x[ids], y[ids], cfg.k
-                    ),
-                    "split_averaging": estimate_split(z_left[ids], z_right[ids], cfg.k),
-                }
-                for estimator in estimators:
-                    raw_rows.append(
-                        {
-                            "seed": seed,
-                            "effective_seed": effective_seed,
-                            "M": m,
-                            "selection": selection,
-                            "selected_clients": int(len(ids)),
-                            "minority_clients": minority,
-                            "estimator": estimator,
-                            "sin_theta_spectral": subspace_error(
-                                b_true, estimates[estimator]
-                            ),
-                        }
-                    )
-
-    raw_csv = outdir / "per_seed_results.csv"
-    with raw_csv.open("w", newline="") as f:
-        writer = csv.DictWriter(f, fieldnames=list(raw_rows[0]))
-        writer.writeheader()
-        writer.writerows(raw_rows)
-
-    grouped: list[dict] = []
-    for estimator in estimators:
-        for m in cfg.m_values:
-            means = {}
-            for selection in ("full", "balanced_oracle"):
-                vals = [
-                    float(r["sin_theta_spectral"])
-                    for r in raw_rows
-                    if r["M"] == m
-                    and r["estimator"] == estimator
-                    and r["selection"] == selection
-                ]
-                mean, low, high = ci95(vals)
-                means[selection] = mean
-                grouped.append(
-                    {
-                        "M": m,
-                        "estimator": estimator,
-                        "selection": selection,
-                        "mean": mean,
-                        "ci95_low": low,
-                        "ci95_high": high,
-                        "seeds": len(vals),
-                    }
-                )
-            # Paired seed-level improvement; positive means balanced is better.
-            full_vals = {
-                int(r["seed"]): float(r["sin_theta_spectral"])
-                for r in raw_rows
-                if r["M"] == m
-                and r["estimator"] == estimator
-                and r["selection"] == "full"
-            }
-            bal_vals = {
-                int(r["seed"]): float(r["sin_theta_spectral"])
-                for r in raw_rows
-                if r["M"] == m
-                and r["estimator"] == estimator
-                and r["selection"] == "balanced_oracle"
-            }
-            deltas = [full_vals[s] - bal_vals[s] for s in sorted(full_vals)]
-            dmean, dlow, dhigh = ci95(deltas)
-            grouped.append(
-                {
-                    "M": m,
-                    "estimator": estimator,
-                    "selection": "paired_full_minus_balanced",
-                    "mean": dmean,
-                    "ci95_low": dlow,
-                    "ci95_high": dhigh,
-                    "seeds": len(deltas),
-                }
-            )
-
-    summary_csv = outdir / "aggregate_results.csv"
-    with summary_csv.open("w", newline="") as f:
-        writer = csv.DictWriter(f, fieldnames=list(grouped[0]))
-        writer.writeheader()
-        writer.writerows(grouped)
-
-    fig, axes = plt.subplots(1, 3, figsize=(14.5, 4.2), sharey=True)
-    titles = {
-        "quadratic_moment_proxy": "Quadratic moment proxy",
-        "pairwise_u_statistic": "Pairwise U-statistic",
-        "split_averaging": "Split averaging",
-    }
-    for ax, estimator in zip(axes, estimators):
-        for selection, label, color, marker in (
-            ("full", "Full population", "#cf4c3c", "o"),
-            ("balanced_oracle", "Balanced oracle", "#1e8c79", "s"),
-        ):
-            rows = [
-                r
-                for r in grouped
-                if r["estimator"] == estimator and r["selection"] == selection
-            ]
-            xvals = [r["M"] for r in rows]
-            yvals = [r["mean"] for r in rows]
-            low = [r["mean"] - r["ci95_low"] for r in rows]
-            high = [r["ci95_high"] - r["mean"] for r in rows]
-            ax.errorbar(
-                xvals,
-                yvals,
-                yerr=[low, high],
-                color=color,
-                marker=marker,
-                linewidth=2,
-                capsize=3,
-                label=label,
-            )
-        ax.set_title(titles[estimator])
-        ax.set_xlabel("Number of clients M")
-        ax.grid(alpha=0.22)
-    axes[0].set_ylabel(r"Subspace error $\|\sin\Theta(B^*,\hat B)\|_2$")
-    axes[-1].legend(frameon=False, loc="upper right")
-    fig.suptitle(
-        f"Independent clustered-source reproduction ({cfg.seeds} paired seeds; "
-        f"d={cfg.d}, k={cfg.k}, n={cfg.n}, minority={cfg.minority_fraction:g})"
-    )
-    fig.tight_layout()
-    plot = outdir / "balanced_vs_full.png"
-    fig.savefig(plot, dpi=180, bbox_inches="tight")
-    plt.close(fig)
-
-    c_max = largest_root_constant()
-    constant_audit = {
-        "literal_smallest_nonnegative_c": 0.0,
-        "largest_positive_c_satisfying_printed_inequality": c_max,
-        "minimum_stable_rank_to_avoid_empty_return_at_largest_c": math.ceil(1 / c_max),
-        "paper_default_k": 6,
-        "algorithm_returns_empty_at_paper_default_because_stable_rank_le_k": c_max * 6 < 1,
-        "printed_inequality_lhs_at_c_max": 320 * (c_max + math.sqrt(2 * c_max)),
-    }
-    (outdir / "algorithm_constant_audit.json").write_text(
-        json.dumps(constant_audit, indent=2) + "\n"
-    )
-
-    # Exact finite-dimensional audit of the algebra in Theorem 2's proof.
-    # Four orthogonal standardized heads occur [80, 40, 40, 40] times.
-    counts = np.asarray([80, 40, 40, 40], dtype=np.float64)
-    witness_m = int(counts.sum())
-    witness_k = int(len(counts))
-    witness_n = 30
-    witness_d = cfg.d
-    lambda_k = float(counts.min() / witness_m)
-    full_n = witness_m * witness_n
-    selected_per_direction = int(counts.min())
-    selected_clients = witness_k * selected_per_direction
-    subset_n = selected_clients * witness_n
-    subset_lambda_1 = subset_lambda_k = 1.0 / witness_k
-    target_rate = math.sqrt(witness_d / (full_n * lambda_k))
-    subset_rate = math.sqrt(
-        witness_d * subset_lambda_1 / (subset_n * subset_lambda_k**2)
-    )
-    theorem_audit = {
-        "head_counts": counts.astype(int).tolist(),
-        "standardized_columns": True,
-        "M": witness_m,
-        "k": witness_k,
-        "n": witness_n,
-        "N": full_n,
-        "lambda_k_full": lambda_k,
-        "lambda_k_ge_1_over_n": lambda_k >= 1.0 / witness_n,
-        "selected_clients": selected_clients,
-        "k_times_lambda_min_AAT": witness_k * selected_per_direction,
-        "selected_condition_number": 1.0,
-        "N_prime": subset_n,
-        "lambda_1_prime": subset_lambda_1,
-        "lambda_k_prime": subset_lambda_k,
-        "sqrt_d_over_N_lambda_k": target_rate,
-        "subset_split_bound_term": subset_rate,
-        "algebraic_ratio": subset_rate / target_rate,
-        "spectral_condition_ratio_normA2_over_M_over_k": counts.max()
-        / (witness_m / witness_k),
-        "scope": "Concrete exact witness and proof-reduction check; not a proof of universal existence.",
-    }
-    (outdir / "theorem_reduction_audit.json").write_text(
-        json.dumps(theorem_audit, indent=2) + "\n"
-    )
-
-    positive = [
-        r
-        for r in grouped
-        if r["selection"] == "paired_full_minus_balanced" and r["ci95_low"] > 0
-    ]
-    all_deltas = [
-        r for r in grouped if r["selection"] == "paired_full_minus_balanced"
-    ]
-    summary = {
-        "paper": {
-            "title": "On the Power of Source Screening for Learning Shared Feature Extractors",
-            "openreview_id": "dTMrITkTr5",
-            "arxiv": "2602.16125v2",
-        },
-        "config": asdict(cfg),
-        "runtime_seconds": time.time() - start,
-        "device": {
-            "requested": cfg.device,
-            "torch_device": str(device),
-            "cuda_available": torch.cuda.is_available(),
-            "cuda_name": torch.cuda.get_device_name(0) if torch.cuda.is_available() else None,
-            "torch_version": torch.__version__,
-            "cuda_version": torch.version.cuda,
-        },
-        "environment": {
-            "python": platform.python_version(),
-            "platform": platform.platform(),
-            "git_commit": git_commit(),
-            "job_id": os.getenv("JOB_ID") or os.getenv("HF_JOB_ID"),
-        },
-        "paired_cells_with_positive_mean": sum(r["mean"] > 0 for r in all_deltas),
-        "paired_cells_total": len(all_deltas),
-        "paired_cells_ci95_strictly_positive": len(positive),
-        "claim_scope": (
-            "Tests the oracle-balanced mechanism underlying Figure 1. It is not an "
-            "implementation or validation of printed Algorithm 1 or heuristic Algorithm 2."
-        ),
-        "constant_audit": constant_audit,
-        "theorem_reduction_audit": theorem_audit,
-    }
-    summary_path = outdir / "summary.json"
-    summary_path.write_text(json.dumps(summary, indent=2) + "\n")
-
-    manifest = {
-        p.name: {"bytes": p.stat().st_size, "sha256": sha256(p)}
-        for p in sorted(outdir.iterdir())
-        if p.is_file() and p.name != "manifest.json"
-    }
-    (outdir / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
-    return summary
-
-
-def parse_args() -> argparse.Namespace:
-    p = argparse.ArgumentParser()
-    p.add_argument("--output-dir", type=Path, required=True)
-    p.add_argument("--device", default="cuda")
-    p.add_argument("--seed-start", type=int, default=0)
-    p.add_argument("--seeds", type=int, default=100)
-    p.add_argument("--d", type=int, default=20)
-    p.add_argument("--k", type=int, default=4)
-    p.add_argument("--n", type=int, default=30)
-    p.add_argument("--minority-fraction", type=float, default=0.2)
-    p.add_argument("--m-values", default="25,50,100,200,400")
-    p.add_argument("--noise-std", type=float, default=1.0)
-    return p.parse_args()
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    cfg = Config(
-        seed_start=args.seed_start,
-        seeds=args.seeds,
-        d=args.d,
-        k=args.k,
-        n=args.n,
-        minority_fraction=args.minority_fraction,
-        m_values=tuple(int(x) for x in args.m_values.split(",")),
-        noise_std=args.noise_std,
-        device=args.device,
-    )
-    result = run(cfg, args.output_dir)
-    print(json.dumps(result, indent=2))
-
-````
-
-
-````output
-lambda_k=0.2; lambda_k>=1/n: true; selected=160=k*lambda_min(AA^T); condition number=1; target term=0.12909944487358055; subset term=0.12909944487358055; ratio=1.0
-````
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_cc76fc18b584", "created_at": "2026-07-17T01:54:17+00:00", "title": "Witness limitation"}
--->
-The finite witness is intentionally elementary: the full head matrix is already constant-conditioned and the selected set is its balanced truncation. It checks the displayed algebra only; it does not exhibit difficult screening, establish an empirical rate, or prove the universal minimax statement.

pages/claim-2-existence-under-the-spectral-condition/page.md

@@ -1,26 +1,12 @@
 # Claim 2: Existence under the spectral condition
 
-
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_b8751603e114", "created_at": "2026-07-17T01:36:04+00:00", "title": "Context and test"}
+{"type":"markdown","id":"cell_claim2_counterexample","created_at":"2026-07-21T13:02:01+00:00","title":"Exact terminology audit and counterexample"}
 -->
-This page checks what matrix Theorem 3 actually constrains, whether its formal conclusion meets the paper's own admissibility definition, and whether a concrete balanced witness exists.
+**Verdict: falsified as the supplied claim is worded.** The supplied claim attributes Theorem 3 to a “spectral-norm condition on the source covariates.” The [primary paper](https://arxiv.org/abs/2602.16125) instead assumes `||A||^2 <= O(M/k)` for the standardized **latent-head matrix** `A=[alpha_1*,...,alpha_M*]`; it is not a condition on observed covariates or their covariance matrices.
 
+An exact counterexample separates the two statements. Let `k=4`, `M=200`, give every source identity covariate covariance (condition number exactly 1), and give all sources the same standardized latent head `e_1`. Every source therefore satisfies the strongest possible covariate spectral condition, but every subset's head matrix has rank 1, `lambda_min(A_S A_S^T)=0`, and no subset can satisfy Definition 2's rank-4 admissibility requirement. Thus a covariate-only spectral condition cannot imply the asserted admissible-subset existence.
 
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_4f0a6fada182", "created_at": "2026-07-17T01:36:05+00:00", "title": "Terminology correction and theorem gap"}
--->
-**Verdict: partially supported; the supplied wording is inaccurate and
-the general proof is not independently validated.** Theorem 3 assumes
-`||A||^2 \lesssim M/k` for the standardized latent-head matrix
-`A=[alpha_1*,...,alpha_M*]`. It is not a condition on observed source
-covariates or their covariance matrices.
+The counterexample and the corrected theorem condition are frozen in [claim2_covariate_counterexample.json](https://huggingface.co/buckets/SabaPivot/repro-source-screening-shared-features-artifacts#independent-theory-scaling/claim2_covariate_counterexample.json) and generated by the public [audit script](https://huggingface.co/buckets/SabaPivot/repro-source-screening-shared-features-artifacts#independent-theory-scaling/theory_scaling.py). This falsifies only the challenge's anchored wording, not the paper's differently stated latent-head theorem.
 
-The formal theorem concludes constant condition number and only
-`|S|=Omega(k lambda_min(AA^T))`, while Definition 2 requires `Theta`. The
-proof also conditions `A_S^T A_S` in a step where the required
-`A_S A_S^T` is rank deficient when `|S|<k`. The `[80,40,40,40]` witness has
-spectral ratio `||A||^2/(M/k)=1.6` and an exactly balanced admissible subset,
-so it supports the intuition only—not the full theorem.