Add independent theory and local proxy scripts

src/reproduce.py

@@ -0,0 +1,194 @@
+"""Independent NumPy checks for the WIRE theory claims.
+
+The script intentionally has no paper-code dependency.  It implements the
+rotation in Eq. (2), computes Laplacian eigenfeatures, and checks the
+permutation/gauge, grid, and effective-resistance statements numerically.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+ROOT = Path(__file__).resolve().parents[1]
+RESULTS = ROOT / "results"
+
+
+def laplacian(n: int, edges: list[tuple[int, int]]) -> np.ndarray:
+    a = np.zeros((n, n), dtype=float)
+    for i, j in edges:
+        a[i, j] = a[j, i] = 1.0
+    return np.diag(a.sum(axis=1)) - a
+
+
+def wire_rotate(z: np.ndarray, features: np.ndarray, frequencies: np.ndarray) -> np.ndarray:
+    """Apply block-diagonal RoPE to rows of z using graph features."""
+    n, d = z.shape
+    assert d % 2 == 0
+    angles = features @ frequencies.T
+    out = z.copy()
+    for block in range(d // 2):
+        c = np.cos(angles[:, block])
+        s = np.sin(angles[:, block])
+        x, y = z[:, 2 * block], z[:, 2 * block + 1]
+        out[:, 2 * block] = c * x - s * y
+        out[:, 2 * block + 1] = s * x + c * y
+    return out
+
+
+def spectral_features(l: np.ndarray, m: int, resistance_weighted: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    eigenvalues, eigenvectors = np.linalg.eigh(l)
+    if resistance_weighted:
+        features = eigenvectors[:, 1:m] / np.sqrt(eigenvalues[1:m])
+    else:
+        features = eigenvectors[:, :m]
+    return features, eigenvalues, eigenvectors
+
+
+def effective_resistance(l: np.ndarray, i: int, j: int) -> float:
+    vals, vecs = np.linalg.eigh(l)
+    pinv = (vecs[:, 1:] / vals[1:]) @ vecs[:, 1:].T
+    return float(pinv[i, i] + pinv[j, j] - 2 * pinv[i, j])
+
+
+def check_claim_1(rng: np.random.Generator) -> dict[str, float]:
+    n, d, m = 12, 8, 4
+    edges = [(i, j) for i in range(n) for j in range(i + 1, n) if rng.random() < 0.22]
+    # Ensure a connected-ish graph for stable spectral features.
+    edges += [(i, i + 1) for i in range(n - 1)]
+    features, _, _ = spectral_features(laplacian(n, edges), m)
+    frequencies = rng.normal(0, 0.7, size=(d // 2, m))
+    z = rng.normal(size=(n, d))
+    rotated = wire_rotate(z, features, frequencies)
+    angles = features @ frequencies.T
+    block_norm_error = 0.0
+    for b in range(d // 2):
+        c, s = np.cos(angles[0, b]), np.sin(angles[0, b])
+        rot = np.array([[c, -s], [s, c]])
+        block_norm_error = max(block_norm_error, abs(np.linalg.det(rot) - 1.0), np.linalg.norm(rot.T @ rot - np.eye(2)))
+    return {
+        "nodes": float(n),
+        "spectral_feature_dim": float(m),
+        "angle_std": float(angles.std()),
+        "rotation_orthogonality_error": float(block_norm_error),
+        "output_finite": float(np.isfinite(rotated).all()),
+    }
+
+
+def check_claim_2(rng: np.random.Generator) -> dict[str, float]:
+    n, d, m = 14, 8, 4
+    edges = [(i, i + 1) for i in range(n - 1)] + [(0, 5), (3, 9), (7, 12), (1, 10)]
+    l = laplacian(n, edges)
+    features, _, u = spectral_features(l, m)
+    perm = rng.permutation(n)
+    lp = l[np.ix_(perm, perm)]
+    fp, _, up = spectral_features(lp, m)
+    expected = u[perm, :m]
+    signs = np.sign(np.sum(fp * expected, axis=0))
+    signs[signs == 0] = 1
+    aligned_feature_error = float(np.max(np.abs(fp * signs - expected)))
+    z = rng.normal(size=(n, d))
+    omega = rng.normal(0, 0.4, size=(d // 2, m))
+    # A sign change is absorbed by the corresponding frequency reparameterisation.
+    omega_perm = omega * signs[None, :]
+    out = wire_rotate(z, features, omega)
+    out_perm = wire_rotate(z[perm], fp, omega_perm)
+    equivariance_error = float(np.max(np.abs(out[perm] - out_perm)))
+
+    # A 4-cycle has a repeated Laplacian eigenvalue (the 2-eigenspace).
+    cycle_edges = [(0, 1), (1, 2), (2, 3), (3, 0)]
+    lc = laplacian(4, cycle_edges)
+    _, vals_c, uc = spectral_features(lc, 4)
+    p2 = np.array([1, 2, 3, 0])
+    _, _, up2 = spectral_features(lc[np.ix_(p2, p2)], 4)
+    # Compare subspaces, not individual basis vectors, in the repeated block.
+    a, b = uc[p2, 1:3], up2[:, 1:3]
+    principal_cosines = np.linalg.svd(a.T @ b, compute_uv=False)
+    return {
+        "permutation_feature_max_error_after_sign_alignment": aligned_feature_error,
+        "permutation_wire_max_error_after_frequency_gauge": equivariance_error,
+        "cycle_degenerate_eigenvalue_pair": float(vals_c[1]),
+        "cycle_degenerate_subspace_min_cosine": float(principal_cosines.min()),
+    }
+
+
+def check_claim_3() -> dict[str, float]:
+    n = 25
+    i = np.arange(n, dtype=float)
+    l = laplacian(n, [(k, k + 1) for k in range(n - 1)])
+    _, vals, u = spectral_features(l, 2)
+    # Theorem 2 uses u_1[i] = -cos((i+1/2) pi / N).
+    raw_formula = -np.cos((i + 0.5) * np.pi / n)
+    formula_scale = np.linalg.norm(raw_formula)
+    formula = raw_formula / formula_scale
+    eig_sign = np.sign(np.dot(u[:, 1], formula)) or 1.0
+    u1 = eig_sign * u[:, 1]
+    formula_error = float(np.max(np.abs(u1 - formula)))
+    recovered_position = np.arccos(-(u1 * formula_scale)) * n / np.pi - 0.5
+    position_error = float(np.max(np.abs(recovered_position - i)))
+    monotone = float(np.all(np.diff(u1) > 0))
+    return {
+        "path_second_eigenvalue": float(vals[1]),
+        "theorem_2_eigenvector_formula_max_error": formula_error,
+        "bijective_coordinate_recovery_max_error": position_error,
+        "coordinate_monotonicity": monotone,
+    }
+
+
+def check_claim_4(rng: np.random.Generator) -> dict[str, float]:
+    n, d = 10, 12
+    edges = [(i, i + 1) for i in range(n - 1)] + [(0, 3), (2, 7), (4, 8), (1, 6)]
+    l = laplacian(n, edges)
+    features, vals, vecs = spectral_features(l, n, resistance_weighted=True)
+    i, j = 1, 8
+    resistance = effective_resistance(l, i, j)
+    std = 0.08
+    q = np.ones(d)
+    k = np.ones(d)
+    qk = float(q @ k)
+    draws = 4096
+    scores = np.empty(draws)
+    delta = features[i] - features[j]
+    for t in range(draws):
+        omega = rng.normal(0, std, size=(d // 2, n - 1))
+        angles = omega @ delta
+        scores[t] = 2 * np.sum(np.cos(angles))
+    exact_gaussian = qk * np.exp(-std**2 * resistance / 2)
+    first_order = qk * (1 - std**2 * resistance / 2)
+    return {
+        "effective_resistance": resistance,
+        "spectral_resistance_identity_error": abs(resistance - float(delta @ delta)),
+        "mc_mean_score": float(scores.mean()),
+        "gaussian_expectation": float(exact_gaussian),
+        "first_order_prediction": float(first_order),
+        "mc_abs_error_to_first_order": float(abs(scores.mean() - first_order)),
+        "mc_standard_error": float(scores.std(ddof=1) / np.sqrt(draws)),
+        "omega_std": std,
+        "nonzero_eigenvalues": float(np.count_nonzero(vals[1:] > 1e-10)),
+    }
+
+
+def main() -> None:
+    rng = np.random.default_rng(18382)
+    results = {
+        "paper": {
+            "title": "Rotary Position Encodings for Graphs",
+            "arxiv": "https://huggingface.co/papers/2509.22259",
+            "openreview": "https://openreview.net/forum?id=trn64znfNx",
+            "reference_code": "https://anonymous.4open.science/r/WIRE_Graphs-4584/",
+        },
+        "claim_1": check_claim_1(rng),
+        "claim_2": check_claim_2(rng),
+        "claim_3": check_claim_3(),
+        "claim_4": check_claim_4(rng),
+    }
+    RESULTS.mkdir(parents=True, exist_ok=True)
+    (RESULTS / "core_results.json").write_text(json.dumps(results, indent=2) + "\n")
+    print(json.dumps(results, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/train_synthetic.py

@@ -0,0 +1,170 @@
+"""Scaled GPU proxy for the paper's monochromatic-subgraph experiment.
+
+This is deliberately a small independent implementation: 5x5 grids with
+random edge deletions, node colours, a transformer regressor, and optional
+spectral WIRE rotations in every self-attention layer.  It is not claimed to
+reproduce the paper's full 10k/1k, 250-epoch run.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch import nn
+
+
+N = 25
+GRID_EDGES = [(r * 5 + c, r * 5 + c + 1) for r in range(5) for c in range(4)]
+GRID_EDGES += [(r * 5 + c, (r + 1) * 5 + c) for r in range(4) for c in range(5)]
+
+
+def make_dataset(count: int, seed: int, ape_dim: int = 3) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    rng = np.random.default_rng(seed)
+    laplacians = np.zeros((count, N, N), dtype=np.float32)
+    colours = rng.integers(0, 2, size=(count, N), dtype=np.int64)
+    labels = np.zeros(count, dtype=np.float32)
+    for b in range(count):
+        edges = [e for e in GRID_EDGES if rng.random() > rng.uniform(0.05, 0.45)]
+        # Keep the grid backbone connected enough for meaningful low modes.
+        a = np.zeros((N, N), dtype=np.float32)
+        for i, j in edges:
+            a[i, j] = a[j, i] = 1.0
+        laplacians[b] = np.diag(a.sum(axis=1)) - a
+        seen = np.zeros(N, dtype=bool)
+        best = 0
+        for start in range(N):
+            if seen[start]:
+                continue
+            colour = colours[b, start]
+            stack = [start]
+            seen[start] = True
+            size = 0
+            while stack:
+                node = stack.pop()
+                size += 1
+                for nxt in np.flatnonzero(a[node]):
+                    if not seen[nxt] and colours[b, nxt] == colour:
+                        seen[nxt] = True
+                        stack.append(int(nxt))
+            best = max(best, size)
+        labels[b] = best / N
+    _, vecs = np.linalg.eigh(laplacians)
+    # Include low-frequency spectral coordinates as APE inputs for both arms;
+    # WIRE uses the same coordinates to generate rotations.
+    spectral = vecs[:, :, : max(ape_dim, 3)]
+    colour_onehot = np.eye(2, dtype=np.float32)[colours]
+    x = np.concatenate([colour_onehot, spectral], axis=-1).astype(np.float32)
+    return torch.from_numpy(x), torch.from_numpy(labels), torch.from_numpy(spectral[:, :, :ape_dim].astype(np.float32))
+
+
+class WireAttention(nn.Module):
+    def __init__(self, d_model: int, heads: int, wire_dim: int):
+        super().__init__()
+        assert d_model % heads == 0 and (d_model // heads) % 2 == 0
+        self.heads = heads
+        self.head_dim = d_model // heads
+        self.wire_dim = wire_dim
+        self.qkv = nn.Linear(d_model, 3 * d_model)
+        self.out = nn.Linear(d_model, d_model)
+        self.freq = nn.Parameter(torch.randn(heads, self.head_dim // 2, max(wire_dim, 1)) * 0.15)
+
+    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
+        batch, nodes, d_model = x.shape
+        q, k, v = self.qkv(x).chunk(3, dim=-1)
+        q = q.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
+        k = k.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
+        v = v.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
+        if self.wire_dim:
+            angles = torch.einsum("bnm,hdm->bhnd", spectral[..., : self.wire_dim], self.freq[..., : self.wire_dim])
+            def rotate(z: torch.Tensor) -> torch.Tensor:
+                z = z.view(batch, self.heads, nodes, self.head_dim // 2, 2)
+                c, s = angles.cos(), angles.sin()
+                x0, x1 = z[..., 0], z[..., 1]
+                return torch.stack([c * x0 - s * x1, s * x0 + c * x1], dim=-1).flatten(-2)
+            q, k = rotate(q), rotate(k)
+        weights = torch.softmax(q @ k.transpose(-1, -2) / self.head_dim**0.5, dim=-1)
+        return self.out((weights @ v).transpose(1, 2).reshape(batch, nodes, d_model))
+
+
+class Block(nn.Module):
+    def __init__(self, d_model: int, heads: int, wire_dim: int):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(d_model)
+        self.attn = WireAttention(d_model, heads, wire_dim)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.ff = nn.Sequential(nn.Linear(d_model, 2 * d_model), nn.GELU(), nn.Linear(2 * d_model, d_model))
+
+    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
+        x = x + self.attn(self.norm1(x), spectral)
+        return x + self.ff(self.norm2(x))
+
+
+class GraphTransformer(nn.Module):
+    def __init__(self, input_dim: int, wire_dim: int):
+        super().__init__()
+        self.embed = nn.Linear(input_dim, 32)
+        self.blocks = nn.ModuleList([Block(32, 4, wire_dim) for _ in range(2)])
+        self.head = nn.Sequential(nn.LayerNorm(32), nn.Linear(32, 1))
+
+    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
+        h = self.embed(x)
+        for block in self.blocks:
+            h = block(h, spectral)
+        return self.head(h.mean(dim=1)).squeeze(-1)
+
+
+def train_arm(train: tuple[torch.Tensor, ...], test: tuple[torch.Tensor, ...], wire_dim: int, seed: int, device: torch.device) -> float:
+    torch.manual_seed(seed)
+    model = GraphTransformer(train[0].shape[-1], wire_dim).to(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-4)
+    x, y, s = [v.to(device) for v in train]
+    xt, yt, st = [v.to(device) for v in test]
+    for _ in range(80):
+        order = torch.randperm(len(x), device=device)
+        for idx in order.split(64):
+            pred = model(x[idx], s[idx])
+            loss = ((pred - y[idx]) ** 2).mean()
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+    model.eval()
+    with torch.no_grad():
+        rmse = float(torch.sqrt(((model(xt, st) - yt) ** 2).mean()).cpu())
+    return rmse
+
+
+def main() -> None:
+    start = time.time()
+    random.seed(18382)
+    np.random.seed(18382)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train = make_dataset(1600, 18382)
+    test = make_dataset(400, 19382)
+    results = {
+        "paper": "https://huggingface.co/papers/2509.22259",
+        "job_proxy": "monochromatic-subgraph; 1,600/400 graphs vs paper 10,000/1,000; 80 vs 250 epochs; 2-layer 32d model vs 4-layer 32d; 2 seeds",
+        "device": str(device),
+        "baseline_rmse": [],
+        "wire_rmse": [],
+    }
+    for seed in (0, 1):
+        results["baseline_rmse"].append(train_arm(train, test, 0, seed, device))
+        results["wire_rmse"].append(train_arm(train, test, 3, seed, device))
+    results["baseline_mean"] = float(np.mean(results["baseline_rmse"]))
+    results["wire_mean"] = float(np.mean(results["wire_rmse"]))
+    results["relative_rmse_change_pct"] = 100 * (results["wire_mean"] / results["baseline_mean"] - 1)
+    results["wall_seconds"] = time.time() - start
+    out_dir = Path("/data") if Path("/data").exists() else Path(".")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / "synthetic_results.json").write_text(json.dumps(results, indent=2) + "\n")
+    print(json.dumps(results, indent=2))
+
+
+if __name__ == "__main__":
+    main()