Update logbook: Repro - NonZero: Interaction-Guided Exploration for Multi-Agent Monte Carlo Tree Search

logbook.json

@@ -10,7 +10,7 @@
     "icml2026-repro",
     "paper-Jh6gq9QsFa"
   ],
-  "updated_at": "2026-08-03T03:19:03+00:00",
+  "updated_at": "2026-08-03T06:36:58+00:00",
   "root": {
     "slug": "index",
     "title": "Repro - NonZero: Interaction-Guided Exploration for Multi-Agent Monte Carlo Tree Search",
@@ -73,10 +73,10 @@
     "total_size": 0,
     "bucket_id": null
   },
-  "agent_view_tokens": 5018,
+  "agent_view_tokens": 2969,
   "trace_view_tokens": 10,
   "workspace_view_tokens": 8,
-  "revision": "5273477ba2d77dcfd419",
+  "revision": "fed69f4f76049e0148bb",
   "workspace_ref": {
     "repo_id": "byte-vortex/nonzero-repro-artifacts",
     "repo_type": "bucket",

pages/claim-1-low-dimensional-nonlinear-surrogate/page.md

@@ -3,300 +3,6 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_435cbf8fde4f", "created_at": "2026-08-03T03:14:57+00:00", "title": "Implemented the asinh-GLM surrogate eta(theta,a) = casinh(alpha<theta,a) exactl…"}
+{"type": "markdown", "id": "cell_6cef8451dcb9", "created_at": "2026-08-03T06:36:45+00:00", "title": "Implemented the asinh-GLM surrogate eta(theta,a) = casinh(alpha<theta,a) exactl…"}
 -->
 Implemented the asinh-GLM surrogate eta(theta,a) = c*asinh(alpha*<theta,a>) exactly per Section 3.1, Eq. 2, plus the first-order (Eq. 3) and mixed second-order (Eq. 4) finite-difference operators. **Verified the paper's stated identity exactly**: eta(a^(u,v)) - eta(a) = Delta_u eta(a) + Delta_v eta(a) + Delta^2_{u,v} eta(a), confirmed to floating-point precision (error ~1.19e-7) via unit test. **[toy]** Verified the surrogate can learn real reward structure: trained on the 8-agent/10-action nonlinear MatGame environment, converged to R2=0.900 on held-out data, matching the theoretical ceiling set by the environment's injected noise variance (Gaussian sigma^2=4 + Uniform(-3,3)) -- essentially recovering all learnable signal. This used a simplified single-global-theta setup rather than the full state-conditioned hypernetwork architecture, so it validates the model family's expressiveness rather than the complete Claim 4 pipeline.
-
-
----
-<!-- trackio-cell
-{"type": "code", "id": "cell_34d10e611c5e", "created_at": "2026-08-03T03:17:33+00:00", "title": "Run: hf claim1_mechanism_test.py (exit 0)", "command": ["hf", "jobs", "uv", "run", "--flavor", "cpu-basic", "--secrets", "HF_TOKEN", "claim1_mechanism_test.py"], "exit_code": 0, "duration_s": 137.193}
--->
-````bash
-$ hf jobs uv run --flavor cpu-basic --secrets HF_TOKEN claim1_mechanism_test.py
-````
-
-exit 0 · 137.2s
-
-
-````python title=claim1_mechanism_test.py
-# /// script
-# dependencies = ["torch", "numpy"]
-# ///
-"""
-Claim 1 -- toy-scale test of NonZero's actual proposal mechanism.
-
-The paper's real claim isn't just "the surrogate can fit rewards" -- it's
-that using the surrogate's first-order (single-agent) and second-order
-(two-agent) difference operators to PROPOSE candidate action changes finds
-good joint actions more efficiently than enumerating/random-sampling the
-full joint-action space (Section 3, Section 3.1).
-
-This script tests that directly: under an EQUAL evaluation budget, does
-NonUCT-style guided local search find better joint actions than random
-sampling, on the 8-agent/10-action nonlinear MatGame environment?
-"""
-
-import torch
-import torch.nn as nn
-import numpy as np
-
-
-class MatgameNonZeroEnv:
-    def __init__(self, n_agents=8, n_actions=10, reward_type="nonlinear",
-                 noise_std=2.0, noise_uniform_range=3.0, seed=None):
-        self.n_agents = n_agents
-        self.n_actions = n_actions
-        self.reward_type = reward_type
-        self.noise_std = noise_std
-        self.noise_uniform_range = noise_uniform_range
-        self._rng = np.random.default_rng(seed)
-
-    def joint_reward(self, actions):
-        base = float(np.sum(actions))
-        if self.reward_type == "linear":
-            return base
-        u = self._rng.normal(0.0, self.noise_std)
-        v = self._rng.uniform(-self.noise_uniform_range, self.noise_uniform_range)
-        return base + u + v
-
-
-class AsinhGLMSurrogate:
-    def __init__(self, n_agents, n_actions, c=1.0, alpha=1.0):
-        self.n_agents, self.n_actions = n_agents, n_actions
-        self.nd = n_agents * n_actions
-        self.c, self.alpha = c, alpha
-
-    def one_hot(self, agent_actions):
-        agent_actions = torch.as_tensor(agent_actions, dtype=torch.long)
-        oh = torch.nn.functional.one_hot(agent_actions, num_classes=self.n_actions)
-        return oh.reshape(*agent_actions.shape[:-1], self.nd).float()
-
-    def eta(self, theta, a):
-        return self.c * torch.asinh(self.alpha * (theta * a).sum(dim=-1))
-
-    def neighbor(self, a, agent_idx, new_action):
-        a = a.clone()
-        s = agent_idx * self.n_actions
-        a[..., s:s + self.n_actions] = 0.0
-        a[..., s + new_action] = 1.0
-        return a
-
-    def neighbor_pair(self, a, agent_i, action_i, agent_j, action_j):
-        a = self.neighbor(a, agent_i, action_i)
-        a = self.neighbor(a, agent_j, action_j)
-        return a
-
-
-def fit_surrogate(env, surrogate, n_samples=4000, n_epochs=1500, rng=None):
-    actions = rng.integers(0, env.n_actions, size=(n_samples, env.n_agents))
-    rewards = torch.tensor([env.joint_reward(a) for a in actions], dtype=torch.float32)
-    a_enc = surrogate.one_hot(torch.tensor(actions, dtype=torch.long))
-
-    theta = nn.Parameter(torch.zeros(surrogate.nd))
-    log_c, log_alpha = nn.Parameter(torch.zeros(())), nn.Parameter(torch.zeros(()))
-    opt = torch.optim.Adam([theta, log_c, log_alpha], lr=0.05)
-    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=n_epochs)
-
-    def predict(a_batch):
-        return torch.exp(log_c) * torch.asinh(torch.exp(log_alpha) * (theta * a_batch).sum(dim=-1))
-
-    for _ in range(n_epochs):
-        opt.zero_grad()
-        loss = ((predict(a_enc) - rewards) ** 2).mean()
-        loss.backward()
-        opt.step()
-        sched.step()
-    return theta.detach()
-
-
-def nonuct_guided_search(env, surrogate, theta, eval_budget, rng):
-    n_agents, n_actions = env.n_agents, env.n_actions
-    current = rng.integers(0, n_actions, size=n_agents)
-    best_reward = env.joint_reward(current)
-    evals_used = 1
-
-    while evals_used < eval_budget:
-        cur_enc = surrogate.one_hot(torch.tensor(current, dtype=torch.long))
-        cur_eta = surrogate.eta(theta, cur_enc).item()
-
-        best_candidate, best_delta, best_kind = None, -float("inf"), None
-        for agent_idx in range(n_agents):
-            for new_action in range(n_actions):
-                if new_action == current[agent_idx]:
-                    continue
-                cand_enc = surrogate.neighbor(cur_enc, agent_idx, new_action)
-                delta = (surrogate.eta(theta, cand_enc) - cur_eta).item()
-                if delta > best_delta:
-                    best_delta, best_candidate, best_kind = delta, (agent_idx, new_action), "first"
-
-        for i in range(n_agents):
-            for j in range(i + 1, n_agents):
-                for ai in range(n_actions):
-                    if ai == current[i]:
-                        continue
-                    for aj in range(n_actions):
-                        if aj == current[j]:
-                            continue
-                        cand_enc = surrogate.neighbor_pair(cur_enc, i, ai, j, aj)
-                        delta = (surrogate.eta(theta, cand_enc) - cur_eta).item()
-                        if delta > best_delta:
-                            best_delta, best_candidate, best_kind = delta, (i, ai, j, aj), "second"
-
-        if best_candidate is None or evals_used >= eval_budget:
-            break
-
-        candidate_actions = current.copy()
-        if best_kind == "first":
-            agent_idx, new_action = best_candidate
-            candidate_actions[agent_idx] = new_action
-        else:
-            i, ai, j, aj = best_candidate
-            candidate_actions[i] = ai
-            candidate_actions[j] = aj
-
-        real_reward = env.joint_reward(candidate_actions)
-        evals_used += 1
-
-        if real_reward > best_reward:
-            current = candidate_actions
-            best_reward = real_reward
-        else:
-            break
-
-    return best_reward, evals_used
-
-
-def random_search(env, eval_budget, rng):
-    best_reward = -float("inf")
-    for _ in range(eval_budget):
-        actions = rng.integers(0, env.n_actions, size=env.n_agents)
-        r = env.joint_reward(actions)
-        if r > best_reward:
-            best_reward = r
-    return best_reward
-
-
-def main():
-    print("=" * 70)
-    print("NonZero reproduction -- Claim 1 mechanism test (toy scale)")
-    print("Testing: does surrogate-guided proposal beat random search")
-    print("under an EQUAL real-environment evaluation budget?")
-    print("=" * 70)
-
-    n_trials = 200
-    eval_budget = 15
-
-    rng_fit = np.random.default_rng(0)
-    env_fit = MatgameNonZeroEnv(n_agents=8, n_actions=10, reward_type="nonlinear", seed=1)
-    surrogate = AsinhGLMSurrogate(8, 10)
-    theta = fit_surrogate(env_fit, surrogate, rng=rng_fit)
-    print(f"\nSurrogate fit complete (theta trained on 4000 samples).")
-
-    guided_rewards, random_rewards = [], []
-    for trial in range(n_trials):
-        rng = np.random.default_rng(1000 + trial)
-        env = MatgameNonZeroEnv(n_agents=8, n_actions=10, reward_type="nonlinear", seed=2000 + trial)
-
-        g_reward, g_evals = nonuct_guided_search(env, surrogate, theta, eval_budget, rng)
-        guided_rewards.append(g_reward)
-
-        env2 = MatgameNonZeroEnv(n_agents=8, n_actions=10, reward_type="nonlinear", seed=2000 + trial)
-        rng2 = np.random.default_rng(1000 + trial)
-        r_reward = random_search(env2, eval_budget, rng2)
-        random_rewards.append(r_reward)
-
-    guided_mean, guided_std = np.mean(guided_rewards), np.std(guided_rewards)
-    random_mean, random_std = np.mean(random_rewards), np.std(random_rewards)
-    improvement = (guided_mean - random_mean) / abs(random_mean) * 100
-
-    print(f"\n[Results over {n_trials} trials, eval_budget={eval_budget}]")
-    print(f"  Surrogate-guided search: {guided_mean:.2f} +/- {guided_std:.2f}")
-    print(f"  Random search (baseline): {random_mean:.2f} +/- {random_std:.2f}")
-    print(f"  Improvement: {improvement:+.1f}%")
-
-    print("\n" + "=" * 70)
-    print("SUMMARY")
-    if guided_mean > random_mean:
-        print(f"  PASS: surrogate-guided proposal outperforms random search")
-        print(f"  by {improvement:.1f}% under equal evaluation budget.")
-        print(f"  This supports Claim 1's core mechanism at toy scale.")
-    else:
-        print(f"  FAIL: surrogate-guided proposal did NOT outperform random search")
-        print(f"  in this toy setting.")
-    print("=" * 70)
-
-
-if __name__ == "__main__":
-    main()
-
-````
-
-
-````output
-/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_experimental.py:59: UserWarning: 'HfApi.run_uv_job' is experimental and might be subject to breaking changes in the future without prior notice. You can disable this warning by setting `HF_HUB_DISABLE_EXPERIMENTAL_WARNING=1` as environment variable.
-  warnings.warn(
-Job started with ID: 6a7007c56b79c09949c20232
-View at: https://huggingface.co/jobs/byte-vortex/6a7007c56b79c09949c20232
-Downloading nvidia-nvshmem-cu13 (57.6MiB)
-Downloading nvidia-nvjitlink (38.9MiB)
-Downloading cuda-bindings (6.3MiB)
-Downloading nvidia-cufile (1.2MiB)
-Downloading numpy (15.9MiB)
-Downloading nvidia-cublas (403.5MiB)
-Downloading nvidia-cuda-cupti (10.2MiB)
-Downloading nvidia-cudnn-cu13 (349.2MiB)
-Downloading sympy (6.0MiB)
-Downloading nvidia-curand (56.8MiB)
-Downloading nvidia-cusolver (191.6MiB)
-Downloading nvidia-nccl-cu13 (196.4MiB)
-Downloading triton (188.6MiB)
-Downloading networkx (2.0MiB)
-Downloading nvidia-cusparselt-cu13 (162.3MiB)
-Downloading torch (502.2MiB)
-Downloading nvidia-cuda-runtime (2.1MiB)
-Downloading nvidia-cufft (204.2MiB)
-Downloading nvidia-cuda-nvrtc (86.0MiB)
-Downloading nvidia-cusparse (139.2MiB)
- Downloaded nvidia-cufile
- Downloaded nvidia-cuda-runtime
- Downloaded networkx
- Downloaded cuda-bindings
- Downloaded nvidia-cuda-cupti
- Downloaded numpy
- Downloaded sympy
- Downloaded nvidia-nvjitlink
- Downloaded nvidia-curand
- Downloaded nvidia-nvshmem-cu13
- Downloaded nvidia-cuda-nvrtc
- Downloaded nvidia-cusparse
- Downloaded nvidia-cusparselt-cu13
- Downloaded nvidia-cusolver
- Downloaded nvidia-nccl-cu13
- Downloaded nvidia-cufft
- Downloaded triton
- Downloaded nvidia-cudnn-cu13
- Downloaded nvidia-cublas
- Downloaded torch
-Installed 30 packages in 224ms
-======================================================================
-NonZero reproduction -- Claim 1 mechanism test (toy scale)
-Testing: does surrogate-guided proposal beat random search
-under an EQUAL real-environment evaluation budget?
-======================================================================
-
-Surrogate fit complete (theta trained on 4000 samples).
-
-[Results over 200 trials, eval_budget=15]
-  Surrogate-guided search: 73.19 +/- 2.59
-  Random search (baseline): 51.04 +/- 4.58
-  Improvement: +43.4%
-
-======================================================================
-SUMMARY
-  PASS: surrogate-guided proposal outperforms random search
-  by 43.4% under equal evaluation budget.
-  This supports Claim 1's core mechanism at toy scale.
-======================================================================
-
-````

pages/claim-2-regret-bound-theorem-3-5/page.md

@@ -3,7 +3,7 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_7d821d584dc1", "created_at": "2026-08-03T03:14:58+00:00", "title": "Proof review (not a numerical claim)"}
+{"type": "markdown", "id": "cell_c5a16f27e326", "created_at": "2026-08-03T06:36:46+00:00", "title": "Proof review (not a numerical claim)"}
 -->
 Actually reviewed the proof this time (arXiv:2605.00751v1, Appendix A.2-A.5), rather than skipping it -- this claim needs no compute, just reading. 
 

pages/claim-3-efficiency-separation-theorem-3-7/page.md

@@ -3,13 +3,6 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_3dd934c2a67c", "created_at": "2026-08-03T03:14:59+00:00", "title": "Not attempted. Same reasoning as Claim 2 -- theoretical claim (Appendix A.6), p…"}
+{"type": "markdown", "id": "cell_fc84cbd6fd77", "created_at": "2026-08-03T06:36:47+00:00", "title": "Not attempted. Same reasoning as Claim 2 -- theoretical claim (Appendix A.6), p…"}
 -->
 Not attempted. Same reasoning as Claim 2 -- theoretical claim (Appendix A.6), proof review deprioritized given time constraints.
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_5335e20a3e7b", "created_at": "2026-08-03T03:19:02+00:00", "title": "Toy numerical illustration"}
--->
-[toy numerical illustration] Not a formal proof-check of Theorem 3.7's exact bound (that would require verifying the proof in Appendix A.6, not code). Instead, numerically measured the guided-search budget needed to reach a near-optimal joint action as the number of agents (n) grows from 3 to 8, and compared against the size of the full joint-action space (d^n) that a standard UCB-style method would need to enumerate for comparable coverage. Measured separation ratios: n=3 -> 160.0x, n=4 -> 1,032.6x, n=5 -> 7,447.3x, n=6 -> 90,394.5x, n=7 -> 533,174.2x, n=8 -> 7,190,235.4x. The ratio grew ~44,939x from n=3 to n=8 while the full joint-action space itself only grew 32,768x over the same range -- i.e. the separation ratio is growing faster than the space itself, consistent with an exponential-in-n advantage as claimed by Theorem 3.7, though this illustrates the qualitative trend rather than verifying the theorem's precise constants.

pages/claim-4-matgame-8-agent-10-action-nonlinear/page.md

@@ -3,327 +3,6 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_bc24ae0bf5e1", "created_at": "2026-08-03T03:15:00+00:00", "title": "[toy / partial] Built a generalized N-agent MatGame environment implementing th…"}
+{"type": "markdown", "id": "cell_47caf832ba70", "created_at": "2026-08-03T06:36:47+00:00", "title": "[toy / partial] Built a generalized N-agent MatGame environment implementing th…"}
 -->
 **[toy / partial]** Built a generalized N-agent MatGame environment implementing the exact reward rule from Appendix D (linear = sum of agent action indices; nonlinear = linear sum + Gaussian(0,2^2) + Uniform(-3,3) noise). Sanity-checked reward scale against Table 1: random-policy episodes on the 8x10 nonlinear config average ~370-380 out of a 720 max, consistent with the paper's trained-baseline range of 587-712 sitting well above random. Confirmed the underlying MAZero codebase (which NonZero extends, per the paper's own Appendix C) builds and trains successfully on a single Kaggle T4 GPU, converging to the optimal joint policy (test score 100.0 +/- 0.0) on the repo's built-in matgame3 config. Began implementing NonUCT's selection rule as a C++ patch to MAZero's MCTS node scoring (cnode.h/cnode.cpp): added hooks for a precomputed surrogate score, blended additively into the existing pUCT formula, gated by a weight defaulting to 0 so baseline behavior is unaffected unless explicitly enabled. This patch compiles successfully. **Not completed**: the Cython bindings (cytree.pyx) needed to call these new C++ hooks from Python were not implemented, so no NonZero-vs-MAZero training comparison was run, and Table 1's actual numbers (697.1 vs 672.3) were not reproduced or falsified.
-
-
----
-<!-- trackio-cell
-{"type": "code", "id": "cell_e6b23a9eda0a", "created_at": "2026-08-03T03:18:41+00:00", "title": "Run: hf claim4_toy_comparison.py (exit 0)", "command": ["hf", "jobs", "uv", "run", "--flavor", "cpu-basic", "--secrets", "HF_TOKEN", "claim4_toy_comparison.py"], "exit_code": 0, "duration_s": 55.853}
--->
-````bash
-$ hf jobs uv run --flavor cpu-basic --secrets HF_TOKEN claim4_toy_comparison.py
-````
-
-exit 0 · 55.9s
-
-
-````python title=claim4_toy_comparison.py
-
-# /// script
-# dependencies = ["torch", "numpy"]
-# ///
-"""
-Claim 4 -- toy-scale head-to-head comparison on the paper's exact
-8-agent, 10-action nonlinear MatGame setting (Table 1). Vectorized
-version: candidate generation uses precomputed batched tensor masks
-instead of per-candidate Python loops, since the naive version is too
-slow for 2000 decisions.
-"""
-
-import torch
-import torch.nn as nn
-import numpy as np
-
-
-class MatgameNonZeroEnv:
-    def __init__(self, n_agents=8, n_actions=10, reward_type="nonlinear",
-                 noise_std=2.0, noise_uniform_range=3.0, seed=None):
-        self.n_agents = n_agents
-        self.n_actions = n_actions
-        self.reward_type = reward_type
-        self.noise_std = noise_std
-        self.noise_uniform_range = noise_uniform_range
-        self._rng = np.random.default_rng(seed)
-
-    def joint_reward(self, actions):
-        base = float(np.sum(actions))
-        if self.reward_type == "linear":
-            return base
-        u = self._rng.normal(0.0, self.noise_std)
-        v = self._rng.uniform(-self.noise_uniform_range, self.noise_uniform_range)
-        return base + u + v
-
-
-class VectorizedProposer:
-    def __init__(self, n_agents, n_actions, c=1.0, alpha=1.0):
-        self.n_agents, self.n_actions = n_agents, n_actions
-        self.nd = n_agents * n_actions
-        self.c, self.alpha = c, alpha
-
-        rows1 = n_agents * n_actions
-        self.agent1 = torch.zeros(rows1, dtype=torch.long)
-        self.action1 = torch.zeros(rows1, dtype=torch.long)
-        self.block_mask1 = torch.zeros(rows1, self.nd)
-        self.target1 = torch.zeros(rows1, self.nd)
-        r = 0
-        for i in range(n_agents):
-            for j in range(n_actions):
-                self.agent1[r], self.action1[r] = i, j
-                self.block_mask1[r, i * n_actions:(i + 1) * n_actions] = 1.0
-                self.target1[r, i * n_actions + j] = 1.0
-                r += 1
-
-        pairs = [(i, j) for i in range(n_agents) for j in range(i + 1, n_agents)]
-        rows2 = len(pairs) * n_actions * n_actions
-        self.pair_i = torch.zeros(rows2, dtype=torch.long)
-        self.pair_j = torch.zeros(rows2, dtype=torch.long)
-        self.action_i = torch.zeros(rows2, dtype=torch.long)
-        self.action_j = torch.zeros(rows2, dtype=torch.long)
-        self.block_mask2 = torch.zeros(rows2, self.nd)
-        self.target2 = torch.zeros(rows2, self.nd)
-        r = 0
-        for (i, j) in pairs:
-            for ai in range(n_actions):
-                for aj in range(n_actions):
-                    self.pair_i[r], self.pair_j[r] = i, j
-                    self.action_i[r], self.action_j[r] = ai, aj
-                    self.block_mask2[r, i * n_actions:(i + 1) * n_actions] = 1.0
-                    self.block_mask2[r, j * n_actions:(j + 1) * n_actions] = 1.0
-                    self.target2[r, i * n_actions + ai] = 1.0
-                    self.target2[r, j * n_actions + aj] = 1.0
-                    r += 1
-
-    def one_hot(self, agent_actions):
-        agent_actions = torch.as_tensor(agent_actions, dtype=torch.long)
-        oh = torch.nn.functional.one_hot(agent_actions, num_classes=self.n_actions)
-        return oh.reshape(-1).float()
-
-    def eta(self, theta, a_batch):
-        return self.c * torch.asinh(self.alpha * (theta.unsqueeze(0) * a_batch).sum(dim=-1))
-
-    def best_candidate(self, theta, cur_enc, current_actions):
-        cur_eta = self.eta(theta, cur_enc.unsqueeze(0)).item()
-
-        cand1 = cur_enc.unsqueeze(0) * (1 - self.block_mask1) + self.target1
-        eta1 = self.eta(theta, cand1)
-        current_action1 = torch.as_tensor(current_actions)[self.agent1]
-        self_mask1 = (self.action1 == current_action1)
-        eta1 = eta1.masked_fill(self_mask1, -float("inf"))
-        delta1 = eta1 - cur_eta
-        best1_val, best1_idx = delta1.max(dim=0)
-
-        cand2 = cur_enc.unsqueeze(0) * (1 - self.block_mask2) + self.target2
-        eta2 = self.eta(theta, cand2)
-        cur_ai = torch.as_tensor(current_actions)[self.pair_i]
-        cur_aj = torch.as_tensor(current_actions)[self.pair_j]
-        self_mask2 = (self.action_i == cur_ai) | (self.action_j == cur_aj)
-        eta2 = eta2.masked_fill(self_mask2, -float("inf"))
-        delta2 = eta2 - cur_eta
-        best2_val, best2_idx = delta2.max(dim=0)
-
-        if best1_val.item() >= best2_val.item():
-            agent_idx, new_action = self.agent1[best1_idx].item(), self.action1[best1_idx].item()
-            candidate_actions = current_actions.copy()
-            candidate_actions[agent_idx] = new_action
-        else:
-            i, j = self.pair_i[best2_idx].item(), self.pair_j[best2_idx].item()
-            ai, aj = self.action_i[best2_idx].item(), self.action_j[best2_idx].item()
-            candidate_actions = current_actions.copy()
-            candidate_actions[i], candidate_actions[j] = ai, aj
-
-        return candidate_actions
-
-
-def fit_surrogate(env, n_agents, n_actions, n_samples=4000, n_epochs=1500, rng=None):
-    actions = rng.integers(0, n_actions, size=(n_samples, n_agents))
-    rewards = torch.tensor([env.joint_reward(a) for a in actions], dtype=torch.float32)
-    onehots = torch.nn.functional.one_hot(torch.tensor(actions, dtype=torch.long), num_classes=n_actions)
-    a_enc = onehots.reshape(n_samples, -1).float()
-
-    nd = n_agents * n_actions
-    theta = nn.Parameter(torch.zeros(nd))
-    log_c, log_alpha = nn.Parameter(torch.zeros(())), nn.Parameter(torch.zeros(()))
-    opt = torch.optim.Adam([theta, log_c, log_alpha], lr=0.05)
-    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=n_epochs)
-
-    for _ in range(n_epochs):
-        opt.zero_grad()
-        pred = torch.exp(log_c) * torch.asinh(torch.exp(log_alpha) * (theta * a_enc).sum(dim=-1))
-        loss = ((pred - rewards) ** 2).mean()
-        loss.backward()
-        opt.step()
-        sched.step()
-    return theta.detach()
-
-
-def nonzero_style_decision(env, proposer, theta, budget, rng):
-    n_agents, n_actions = env.n_agents, env.n_actions
-    current = rng.integers(0, n_actions, size=n_agents)
-    best_reward = env.joint_reward(current)
-    evals_used = 1
-
-    while evals_used < budget:
-        cur_enc = proposer.one_hot(current)
-        candidate_actions = proposer.best_candidate(theta, cur_enc, current)
-        real_reward = env.joint_reward(candidate_actions)
-        evals_used += 1
-
-        if real_reward > best_reward:
-            current = candidate_actions
-            best_reward = real_reward
-        else:
-            break
-
-    return best_reward
-
-
-def mazero_style_decision(env, budget, rng):
-    best_reward = -float("inf")
-    for _ in range(budget):
-        actions = rng.integers(0, env.n_actions, size=env.n_agents)
-        r = env.joint_reward(actions)
-        if r > best_reward:
-            best_reward = r
-    return best_reward
-
-
-def main():
-    print("=" * 70)
-    print("NonZero reproduction -- Claim 4 toy comparison (vectorized)")
-    print("Setting: 8 agents, 10 actions, nonlinear (Table 1's hardest config)")
-    print("2000 sequential decisions, equal real-eval budget per decision")
-    print("=" * 70)
-
-    n_agents, n_actions = 8, 10
-    n_steps = 2000
-    budget_per_step = 15
-
-    rng_fit = np.random.default_rng(0)
-    env_fit = MatgameNonZeroEnv(n_agents=n_agents, n_actions=n_actions,
-                                 reward_type="nonlinear", seed=1)
-    theta = fit_surrogate(env_fit, n_agents, n_actions, rng=rng_fit)
-    proposer = VectorizedProposer(n_agents, n_actions)
-    print(f"\nSurrogate fit complete. Candidate masks precomputed "
-          f"({proposer.block_mask1.shape[0]} first-order + "
-          f"{proposer.block_mask2.shape[0]} second-order candidates/decision).")
-
-    nonzero_rewards, mazero_rewards = [], []
-    for step in range(n_steps):
-        env_a = MatgameNonZeroEnv(n_agents=n_agents, n_actions=n_actions,
-                                   reward_type="nonlinear", seed=5000 + step)
-        rng_a = np.random.default_rng(3000 + step)
-        nonzero_rewards.append(nonzero_style_decision(env_a, proposer, theta, budget_per_step, rng_a))
-
-        env_b = MatgameNonZeroEnv(n_agents=n_agents, n_actions=n_actions,
-                                   reward_type="nonlinear", seed=5000 + step)
-        rng_b = np.random.default_rng(3000 + step)
-        mazero_rewards.append(mazero_style_decision(env_b, budget_per_step, rng_b))
-
-        if (step + 1) % 400 == 0:
-            print(f"  ...{step + 1}/{n_steps} decisions completed")
-
-    nz_mean, nz_std = np.mean(nonzero_rewards), np.std(nonzero_rewards)
-    mz_mean, mz_std = np.mean(mazero_rewards), np.std(mazero_rewards)
-    improvement = (nz_mean - mz_mean) / abs(mz_mean) * 100
-
-    print(f"\n[Results over {n_steps} decisions, budget={budget_per_step}/decision]")
-    print(f"  NonZero-style (guided proposal):  {nz_mean:.2f} +/- {nz_std:.2f}")
-    print(f"  MAZero-style (random sampled):    {mz_mean:.2f} +/- {mz_std:.2f}")
-    print(f"  Improvement: {improvement:+.1f}%")
-
-    print("\n" + "=" * 70)
-    print("SUMMARY")
-    if nz_mean > mz_mean:
-        print(f"  PASS (toy scale): NonZero-style guided proposal outperforms")
-        print(f"  MAZero-style random sampling by {improvement:.1f}% under equal budget.")
-    else:
-        print(f"  FAIL: guided proposal did NOT outperform the baseline.")
-    print("=" * 70)
-
-
-if __name__ == "__main__":
-    main()
-
-````
-
-
-````output
-/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_experimental.py:59: UserWarning: 'HfApi.run_uv_job' is experimental and might be subject to breaking changes in the future without prior notice. You can disable this warning by setting `HF_HUB_DISABLE_EXPERIMENTAL_WARNING=1` as environment variable.
-  warnings.warn(
-Job started with ID: 6a70085a6b79c09949c20239
-View at: https://huggingface.co/jobs/byte-vortex/6a70085a6b79c09949c20239
-Downloading nvidia-cuda-runtime (2.1MiB)
-Downloading nvidia-cudnn-cu13 (349.2MiB)
-Downloading nvidia-nvjitlink (38.9MiB)
-Downloading numpy (15.9MiB)
-Downloading nvidia-cuda-cupti (10.2MiB)
-Downloading nvidia-nvshmem-cu13 (57.6MiB)
-Downloading torch (502.2MiB)
-Downloading nvidia-cublas (403.5MiB)
-Downloading sympy (6.0MiB)
-Downloading nvidia-cusolver (191.6MiB)
-Downloading triton (188.6MiB)
-Downloading nvidia-cusparse (139.2MiB)
-Downloading nvidia-cuda-nvrtc (86.0MiB)
-Downloading nvidia-cusparselt-cu13 (162.3MiB)
-Downloading nvidia-curand (56.8MiB)
-Downloading nvidia-cufile (1.2MiB)
-Downloading nvidia-nccl-cu13 (196.4MiB)
-Downloading cuda-bindings (6.3MiB)
-Downloading nvidia-cufft (204.2MiB)
-Downloading networkx (2.0MiB)
- Downloaded nvidia-cufile
- Downloaded nvidia-cuda-runtime
- Downloaded networkx
- Downloaded cuda-bindings
- Downloaded nvidia-cuda-cupti
- Downloaded numpy
- Downloaded nvidia-nvjitlink
- Downloaded sympy
- Downloaded nvidia-curand
- Downloaded nvidia-nvshmem-cu13
- Downloaded nvidia-cuda-nvrtc
- Downloaded nvidia-cusparse
- Downloaded nvidia-cusparselt-cu13
- Downloaded nvidia-cusolver
- Downloaded nvidia-nccl-cu13
- Downloaded nvidia-cufft
- Downloaded triton
- Downloaded nvidia-cudnn-cu13
- Downloaded nvidia-cublas
- Downloaded torch
-Installed 30 packages in 233ms
-======================================================================
-NonZero reproduction -- Claim 4 toy comparison (vectorized)
-Setting: 8 agents, 10 actions, nonlinear (Table 1's hardest config)
-2000 sequential decisions, equal real-eval budget per decision
-======================================================================
-
-Surrogate fit complete. Candidate masks precomputed (80 first-order + 2800 second-order candidates/decision).
-  ...400/2000 decisions completed
-  ...800/2000 decisions completed
-  ...1200/2000 decisions completed
-  ...1600/2000 decisions completed
-  ...2000/2000 decisions completed
-
-[Results over 2000 decisions, budget=15/decision]
-  NonZero-style (guided proposal):  72.97 +/- 2.59
-  MAZero-style (random sampled):    50.84 +/- 4.51
-  Improvement: +43.5%
-
-======================================================================
-SUMMARY
-  PASS (toy scale): NonZero-style guided proposal outperforms
-  MAZero-style random sampling by 43.5% under equal budget.
-======================================================================
-
-````
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_f8bf8352bab1", "created_at": "2026-08-03T03:18:46+00:00", "title": "NonUCT integration -- deeper findings (not completed)"}
--->
-Deeper investigation into wiring NonUCT into the real MCTS search (beyond the toy comparison above): confirmed each C++ tree node stores its own joint action (`int *action`) that led to it, and that Python-to-C++ bindings for setting a NonUCT weight/scores were successfully built and tested (see the batch-bindings patch). However, full integration requires more than initially scoped: child actions are sampled and deduplicated internally in C++ (variable count per node, unknown to Python in advance), meaning real wiring needs additional getters to query actual sampled actions per node after each expansion, a trained state-conditioned theta-head network (a real architecture/training-loop change), and careful indexing into the node pool. This was assessed as a substantial additional engineering effort beyond what could be safely completed and verified without live debugging capability, and was not completed. Documenting this honestly rather than shipping unverified wiring.

pages/claim-5-smac-win-rate/page.md

@@ -3,6 +3,6 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_b2d27aa58fe1", "created_at": "2026-08-03T03:15:01+00:00", "title": "Not attempted. The official MAZero training recipe (which NonZero extends) targ…"}
+{"type": "markdown", "id": "cell_c196a0862a2f", "created_at": "2026-08-03T06:36:48+00:00", "title": "Not attempted. The official MAZero training recipe (which NonZero extends) targ…"}
 -->
 Not attempted. The official MAZero training recipe (which NonZero extends) targets an NVIDIA A100 80GB per the repository documentation; free-tier compute available (Kaggle T4/P100, 16GB) is well below this, and SMAC training runs reported in the paper likely require many hours even for baseline methods. A heavily reduced/short-horizon smoke test was considered but would not produce numbers comparable to Figure 1's claims, so was not attempted rather than reporting a misleading partial result.

pages/claim-6-smacv2-win-rate-ablations/page.md

@@ -3,6 +3,6 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_3ceab82f71e9", "created_at": "2026-08-03T03:15:02+00:00", "title": "Not attempted. Same reasoning as Claim 5 -- SMACv2 has the same compute require…"}
+{"type": "markdown", "id": "cell_5e797dcc3d36", "created_at": "2026-08-03T06:36:49+00:00", "title": "Not attempted. Same reasoning as Claim 5 -- SMACv2 has the same compute require…"}
 -->
 Not attempted. Same reasoning as Claim 5 -- SMACv2 has the same compute requirements as SMAC, out of reach on available free-tier GPU.

pages/conclusion/page.md

@@ -3,26 +3,8 @@
 
 ---
 <!-- trackio-cell
-{"type": "artifact", "id": "cell_0b5825058957", "created_at": "2026-08-03T03:15:03+00:00", "title": "Reproduction bundle (environment, surrogate, validation script, C++ patch)", "artifact": "nonzero-repro/repro-bundle:v1", "artifact_type": "dataset"}
+{"type": "artifact", "id": "cell_d56cc802b908", "created_at": "2026-08-03T06:36:50+00:00", "title": "Reproduction bundle (environment, surrogate, validation script, C++ patch)", "artifact": "nonzero-repro/repro-bundle:v1", "artifact_type": "dataset"}
 -->
 **📦 Artifact** `nonzero-repro/repro-bundle:v1` · dataset
 
 trackio-artifact://nonzero-repro/repro-bundle:v1
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_23f926b46ab4", "created_at": "2026-08-03T03:15:12+00:00", "title": "Acknowledgments"}
--->
-This reproduction was completed with assistance from Claude (Anthropic), used as a coding/research agent throughout: reading and interpreting the paper, writing and debugging the environment/surrogate/C++ code, diagnosing build and Kaggle environment issues, and drafting this logbook. All claims of what was and wasn't verified reflect the actual code that was run and its outputs, checked at each step before being reported here.
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_eb82b0dcf26b", "created_at": "2026-08-03T03:17:40+00:00", "title": "Supporting code (corrected)"}
--->
-All supporting code for this reproduction (the MatGame environment, asinh-GLM surrogate, validation script, and the NonUCT C++ patch) is available in this reproduction's Hugging Face Bucket:
-
-hf://buckets/byte-vortex/nonzero-repro-artifacts
-
-Browsable at: https://huggingface.co/buckets/byte-vortex/nonzero-repro-artifacts

pages/executive-summary/page.md

@@ -3,7 +3,7 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_136a6c0f90f6", "created_at": "2026-08-03T03:15:04+00:00", "title": "Executive summary", "pinned": true, "pinned_at": "2026-08-03T03:15:05+00:00"}
+{"type": "markdown", "id": "cell_d88acdf95264", "created_at": "2026-08-03T06:36:51+00:00", "title": "Executive summary", "pinned": true, "pinned_at": "2026-08-03T06:36:52+00:00"}
 -->
 Partial reproduction of NonZero. Of the paper's 6 claims, Claim 1's core mathematical formulation was verified exactly (finite-difference identity holds to floating-point precision), and the surrogate model was shown to learn true reward structure at its theoretical noise ceiling (R2=0.90) on a toy-scale test. Claim 4's supporting infrastructure (environment, baseline training pipeline, and a compiling but not-yet-wired C++ patch for NonUCT) was built and validated at the component level, but no end-to-end NonZero-vs-baseline comparison was completed, so Table 1's reported numbers were neither reproduced nor falsified. Claims 2-3 (theoretical proofs) and Claims 5-6 (SMAC/SMACv2) were not attempted: the former due to time constraints, the latter because the paper's own training recipe requires A100-class GPU hardware unavailable on free-tier compute. All work was done on a single Kaggle T4 GPU, free tier, over approximately 3 hours.
 
@@ -20,7 +20,7 @@ Partial reproduction of NonZero. Of the paper's 6 claims, Claim 1's core mathema
 
 ---
 <!-- trackio-cell
-{"type": "figure", "id": "cell_5e6639f110f0", "created_at": "2026-08-03T03:15:07+00:00", "title": "Poster", "pinned": true, "pinned_at": "2026-08-03T03:15:08+00:00"}
+{"type": "figure", "id": "cell_735d6e9d1f35", "created_at": "2026-08-03T06:36:56+00:00", "title": "Poster", "pinned": true, "pinned_at": "2026-08-03T06:36:56+00:00"}
 -->
 ````html
 <!DOCTYPE html>
@@ -69,20 +69,3 @@ Partial reproduction of NonZero. Of the paper's 6 claims, Claim 1's core mathema
   <footer>Full logbook: <a href="https://huggingface.co/spaces/byte-vortex/nonzero-repro">huggingface.co/spaces/byte-vortex/nonzero-repro</a></footer>
 </body></html>
 ````
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_a5ec59b3a5d2", "created_at": "2026-08-03T03:18:45+00:00", "title": "Executive summary (updated)"}
--->
-Partial reproduction of NonZero. Of the paper's 6 claims: Claim 1 was verified at toy scale with genuine evidence -- the finite-difference identity holds exactly, and a real Hugging Face Job run showed the paper's full proposal mechanism (first- and second-order difference operators) outperforming random search by 43.4% under equal evaluation budget. Claim 2 (regret bound, Theorem 3.5) was reviewed against the actual proof in the paper (Appendix A.2-A.5): the proof strategy and algebra are internally consistent and use standard techniques, but it analyzes an idealized continuous-update proxy for NonUCT rather than the literal discrete finite-difference mechanism in Algorithm 1, and its complexity constants aren't derived for the paper's actual hypernetwork architecture -- so the proof holds as written but leaves an unverified gap between theory and the described algorithm. Claim 3 (efficiency separation, Theorem 3.7) has a toy numerical illustration extended to n=3..8 agents: the guided-search-budget-vs-full-space separation ratio grew from 160x (n=3) to ~7.19 million x (n=8), a ~44,939x growth while the full joint-action space itself only grew 32,768x over the same range -- consistent with the theorem's claimed exponential-in-n advantage, though this is a qualitative illustration, not a check of the theorem's exact constants. Claim 4 has a toy-scale empirical result (a real HF Job showing the same mechanism outperforming a MAZero-style random-sampling baseline by 43.5% on the paper's exact 8-agent/10-action/nonlinear configuration) plus validated supporting infrastructure (environment, baseline training pipeline, and a compiling C++ patch for NonUCT) -- but no full trained NonZero-vs-baseline comparison was completed, so Table 1's exact reported numbers (697.1 vs 672.3) were neither reproduced nor falsified. Claims 5-6 (SMAC/SMACv2) were not attempted: the paper's own training recipe requires A100-class GPU hardware unavailable on free-tier compute.
-
-## Scope & cost
-
-|  | This reproduction | Full replication |
-|---|---|---|
-| Scope | Claim 1 (verified, toy) + Claim 2 (proof reviewed) + Claim 3 (extended toy illustration) + Claim 4 (toy empirical result + infrastructure) | All 6 claims incl. SMAC/SMACv2 |
-| Hardware | Kaggle T4 (free tier) + Hugging Face Jobs (cpu-basic) | Cluster of NVIDIA A100/A6000 GPUs |
-| Compute time | ~3-4 hours | Many GPU-days |
-| Cost | $0 | Thousands of dollars |
-| Outcome | Claim 1 verified (toy scale, real evidence); Claim 2 proof reviewed (gap noted, not a numerical claim); Claim 3 toy illustration extended (n=3..8); Claim 4 toy result + infrastructure validated, full comparison not completed; Claims 5-6 not attempted (compute-bound) |

workspace.json

@@ -8,21 +8,6 @@
       "url": "https://huggingface.co/spaces/byte-vortex/nonzero-repro",
       "type": "Spaces",
       "label": "byte-vortex/nonzero-repro"
-    },
-    {
-      "url": "https://huggingface.co/jobs/byte-vortex/6a7007c56b79c09949c20232",
-      "type": "Jobs",
-      "label": "byte-vortex/6a7007c56b79c09949c20232"
-    },
-    {
-      "url": "https://huggingface.co/jobs/byte-vortex/6a70085a6b79c09949c20239",
-      "type": "Jobs",
-      "label": "byte-vortex/6a70085a6b79c09949c20239"
-    },
-    {
-      "url": "https://huggingface.co/buckets/byte-vortex/nonzero-repro-artifacts",
-      "type": "Buckets",
-      "label": "byte-vortex/nonzero-repro-artifacts"
     }
   ],
   "reference_only": true