#!/usr/bin/env python3 """Batched GPU audit of Claim 2 on the paper's lambda_B ring setup.""" from __future__ import annotations import argparse import json import math import time import torch WEIGHTS = [0.4, 2.2, 1.2, 0.5, 1.0, 0.6, 1.5, 0.5, 1.0, 0.7, 1.3, 0.9, 1.4, 0.6, 1.2, 1.0] def mh_ring(weights: torch.Tensor, epsilon: float = 0.3) -> torch.Tensor: n = len(weights) matrix = torch.zeros((n, n), dtype=weights.dtype, device=weights.device) degree = 2.0 for i in range(n): for j in ((i - 1) % n, (i + 1) % n): acceptance = min(1.0, float(weights[j] / weights[i])) matrix[i, j] = (1.0 - epsilon) * acceptance / degree matrix[i, i] = 1.0 - matrix[i].sum() return matrix def centered_radius(matrix: torch.Tensor, weights: torch.Tensor) -> float: n = len(weights) projection = torch.ones((n, 1), dtype=matrix.dtype, device=matrix.device) @ (weights[None, :] / n) return float(torch.linalg.eigvals(matrix - projection).abs().max().cpu()) def paired_stats(values: torch.Tensor) -> dict: values = values.double() mean = float(values.mean().cpu()) se = float((values.std(unbiased=True) / math.sqrt(values.numel())).cpu()) return { "mean": mean, "ci95": [mean - 1.96 * se, mean + 1.96 * se], "positive_fraction": float((values > 0).double().mean().cpu()), } def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--trials", type=int, default=4096) parser.add_argument("--iterations", type=int, default=300) parser.add_argument("--alpha", type=float, default=0.02) parser.add_argument("--noise-std", type=float, default=1.0) parser.add_argument("--device", default="cuda") args = parser.parse_args() if args.device == "cuda" and not torch.cuda.is_available(): raise RuntimeError("CUDA requested but unavailable") device = torch.device(args.device) dtype = torch.float64 generator = torch.Generator(device=device).manual_seed(20260722) n, dimension = 16, 10 weights = torch.tensor(WEIGHTS, device=device, dtype=dtype) weights = weights * n / weights.sum() row = mh_ring(weights) doubly = mh_ring(torch.ones_like(weights)) rho_lambda = centered_radius(row, weights) rho_j = centered_radius(doubly, torch.ones_like(weights)) zeta = torch.empty((args.trials, n), device=device, dtype=dtype).uniform_(5.5, 12.5, generator=generator) curvature = zeta + 0.01 base = torch.randn((args.trials, 1, dimension), device=device, dtype=dtype, generator=generator) directions = torch.randn((args.trials, n, dimension), device=device, dtype=dtype, generator=generator) directions = directions / torch.linalg.vector_norm(directions, dim=2, keepdim=True) centers = base + 3.0 * directions theta0 = torch.randn((args.trials, n, dimension), device=device, dtype=dtype, generator=generator) noise0 = torch.randn((args.trials, n, dimension), device=device, dtype=dtype, generator=generator) theta_ds = theta0.clone() theta_row = theta0.clone() true_ds = curvature[:, :, None] * theta_ds - zeta[:, :, None] * centers true_row = true_ds.clone() stochastic_ds = true_ds + args.noise_std * noise0 stochastic_row = true_row + args.noise_std * noise0 tracker_ds = weights[None, :, None] * stochastic_ds tracker_row = stochastic_row.clone() auc_ds = torch.zeros(args.trials, device=device, dtype=dtype) auc_row = torch.zeros_like(auc_ds) tail_ds = torch.zeros_like(auc_ds) tail_row = torch.zeros_like(auc_ds) if device.type == "cuda": torch.cuda.synchronize() started = time.perf_counter() for step in range(args.iterations): norm_ds = torch.linalg.vector_norm((weights[None, :, None] * true_ds).mean(dim=1), dim=1) norm_row = torch.linalg.vector_norm((weights[None, :, None] * true_row).mean(dim=1), dim=1) auc_ds += norm_ds auc_row += norm_row if step >= args.iterations - 30: tail_ds += norm_ds tail_row += norm_row next_theta_ds = torch.einsum("ij,sjd->sid", doubly, theta_ds - args.alpha * tracker_ds) next_theta_row = torch.einsum("ij,sjd->sid", row, theta_row - args.alpha * tracker_row) next_true_ds = curvature[:, :, None] * next_theta_ds - zeta[:, :, None] * centers next_true_row = curvature[:, :, None] * next_theta_row - zeta[:, :, None] * centers noise = torch.randn((args.trials, n, dimension), device=device, dtype=dtype, generator=generator) next_stochastic_ds = next_true_ds + args.noise_std * noise next_stochastic_row = next_true_row + args.noise_std * noise next_tracker_ds = torch.einsum("ij,sjd->sid", doubly, tracker_ds) + weights[None, :, None] * (next_stochastic_ds - stochastic_ds) next_tracker_row = torch.einsum("ij,sjd->sid", row, tracker_row) + (next_stochastic_row - stochastic_row) theta_ds, theta_row = next_theta_ds, next_theta_row true_ds, true_row = next_true_ds, next_true_row stochastic_ds, stochastic_row = next_stochastic_ds, next_stochastic_row tracker_ds, tracker_row = next_tracker_ds, next_tracker_row if device.type == "cuda": torch.cuda.synchronize() elapsed = time.perf_counter() - started auc_ds /= args.iterations auc_row /= args.iterations tail_ds /= 30.0 tail_row /= 30.0 result = { "device": str(device), "gpu_name": torch.cuda.get_device_name(0) if device.type == "cuda" else None, "torch_version": torch.__version__, "dtype": str(dtype), "trials": args.trials, "iterations": args.iterations, "alpha": args.alpha, "noise_std": args.noise_std, "rho_j": rho_j, "rho_lambda": rho_lambda, "gap_j": 1.0 - rho_j, "gap_lambda": 1.0 - rho_lambda, "row_gap_is_smaller": (1.0 - rho_lambda) < (1.0 - rho_j), "ds_tail_mean": float(tail_ds.mean().cpu()), "row_tail_mean": float(tail_row.mean().cpu()), "tail_improvement_percent": float((100.0 * (1.0 - tail_row.mean() / tail_ds.mean())).cpu()), "paired_tail_ds_minus_row": paired_stats(tail_ds - tail_row), "ds_auc_mean": float(auc_ds.mean().cpu()), "row_auc_mean": float(auc_row.mean().cpu()), "auc_improvement_percent": float((100.0 * (1.0 - auc_row.mean() / auc_ds.mean())).cpu()), "paired_auc_ds_minus_row": paired_stats(auc_ds - auc_row), "runtime_seconds": elapsed, } print("RESULT_JSON_START") print(json.dumps(result, indent=2)) print("RESULT_JSON_END") if __name__ == "__main__": main()