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-03T01:58:09+00:00",
+  "updated_at": "2026-08-03T02:24:37+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": 3851,
+  "agent_view_tokens": 2940,
   "trace_view_tokens": 10,
   "workspace_view_tokens": 8,
-  "revision": "3786f14b9a573b675081",
+  "revision": "ac503ddb0980b9cbf6c5",
   "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_7ccf974c6f4f", "created_at": "2026-08-03T01:53:39+00:00", "title": "Implemented the asinh-GLM surrogate eta(theta,a) = casinh(alpha<theta,a) exactl…"}
+{"type": "markdown", "id": "cell_a26eb969299b", "created_at": "2026-08-03T02:23:41+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_fd591b62e1cb", "created_at": "2026-08-03T01:56:58+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": 138.56}
--->
-````bash
-$ hf jobs uv run --flavor cpu-basic --secrets HF_TOKEN claim1_mechanism_test.py
-````
-
-exit 0 · 138.6s
-
-
-````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: 6a6ff4e06b79c09949c200e0
-View at: https://huggingface.co/jobs/byte-vortex/6a6ff4e06b79c09949c200e0
-Downloading numpy (15.9MiB)
-Downloading cuda-bindings (6.3MiB)
-Downloading torch (502.2MiB)
-Downloading nvidia-cusolver (191.6MiB)
-Downloading nvidia-nccl-cu13 (196.4MiB)
-Downloading nvidia-cuda-nvrtc (86.0MiB)
-Downloading networkx (2.0MiB)
-Downloading nvidia-nvshmem-cu13 (57.6MiB)
-Downloading nvidia-nvjitlink (38.9MiB)
-Downloading nvidia-cublas (403.5MiB)
-Downloading nvidia-cufft (204.2MiB)
-Downloading nvidia-curand (56.8MiB)
-Downloading triton (188.6MiB)
-Downloading nvidia-cusparselt-cu13 (162.3MiB)
-Downloading nvidia-cufile (1.2MiB)
-Downloading nvidia-cusparse (139.2MiB)
-Downloading nvidia-cuda-cupti (10.2MiB)
-Downloading sympy (6.0MiB)
-Downloading nvidia-cuda-runtime (2.1MiB)
-Downloading nvidia-cudnn-cu13 (349.2MiB)
- 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 228ms
-======================================================================
-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,6 +3,12 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_2659650d5d36", "created_at": "2026-08-03T01:53:40+00:00", "title": "Not attempted. This is a theoretical claim (regret bound proof, Appendix A.4) r…"}
+{"type": "markdown", "id": "cell_34a0f8b8583d", "created_at": "2026-08-03T02:23:42+00:00", "title": "Proof review (not a numerical claim)"}
 -->
-Not attempted. This is a theoretical claim (regret bound proof, Appendix A.4) rather than an empirical one; reviewing the proof for correctness was deprioritized in favor of the empirical claims given time constraints. No numerical claim is made here.
+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. 
+
+**What holds up:** the overall proof strategy is a standard and sound template: (1) Lemma 3.3 shows one-step ascent modulo estimation error via a descent-lemma argument (first-order case) plus cubic-regularization (second-order/negative-curvature case); the algebra checks out exactly -- e.g. the linear error term <g_t,e_t> cancels exactly at step size 1/zeta_h, which is correct arithmetic, not hand-waving. (2) Lemma 3.4 bounds cumulative estimation error via Azuma-Hoeffding + sequential Rademacher complexity + Talagrand's contraction, giving the O(T^{3/4}) rate; this is a fairly standard online-to-batch / fast-rate argument and the WX*sqrt(T) bound for a norm-bounded linear class is a textbook result. (3) Theorem 3.5's proof is a clean telescoping sum combining (1) and (2); the final algebra (dividing through by the improvement rate nu(epsilon) to get K(epsilon)) matches the stated bound exactly. 
+
+**Two real gaps, not just nitpicks:** (a) Lemma 3.3's proof analyzes an idealized *continuous* gradient/cubic-regularized update in a latent embedding space (via the phi(a) embedding introduced in Appendix A.1), not the actual discrete NonUCT candidate-proposal rule described in Section 3.1 and Algorithm 1 (finite differences + argmax over a fixed candidate set C(s)). The paper doesn't show these two update rules are equivalent or bound the gap between them -- it's a common style of idealized-proxy analysis in this literature, but it means the theorem is proven for a model of the algorithm, not verified against the literal pseudocode in Algorithm 1. (b) The smoothness constants (zeta_h, zeta_3rd) and the dimension-dependent complexity term WX ~ sqrt(nd) used in Theorem 3.7's derivation are introduced via a generic Lipschitz/embedding argument (Appendix A.1) rather than computed concretely for the paper's actual architecture, which includes a hypernetwork-initialized theta (Section 3.3) -- a much richer model than the fixed linear/asinh-GLM class the complexity bound in Lemma 3.4 is derived for. 
+
+**Verdict:** the proof is internally consistent and uses correct, recognizable techniques throughout -- no obvious algebraic errors were found in Lemmas 3.3-3.4 or Theorem 3.5's combination step. The main open question, not resolved in the paper, is whether the idealized continuous-update analysis and the generic complexity constants actually transfer to the discrete, hypernetwork-based NonUCT mechanism used in practice. This is a genuine review, not a from-scratch re-derivation or a formal proof checker; no numerical claim is made here.

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

@@ -3,13 +3,6 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_1b039c308c22", "created_at": "2026-08-03T01:53:41+00:00", "title": "Not attempted. Same reasoning as Claim 2 -- theoretical claim (Appendix A.6), p…"}
+{"type": "markdown", "id": "cell_ecbe6283c15e", "created_at": "2026-08-03T02:23:43+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_9c209de3baa5", "created_at": "2026-08-03T01:58:08+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 6, 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. The resulting separation ratio grew from ~160x to ~90,394x -- steep, monotonic growth consistent with the theorem's claimed exponential advantage in n, 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_0ddc2d029999", "created_at": "2026-08-03T01:53:42+00:00", "title": "[toy / partial] Built a generalized N-agent MatGame environment implementing th…"}
+{"type": "markdown", "id": "cell_4ad8e1fda18d", "created_at": "2026-08-03T02:23:44+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_68c7c619d5ee", "created_at": "2026-08-03T01:58:01+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": 54.53}
--->
-````bash
-$ hf jobs uv run --flavor cpu-basic --secrets HF_TOKEN claim4_toy_comparison.py
-````
-
-exit 0 · 54.5s
-
-
-````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: 6a6ff5736b79c09949c200e4
-View at: https://huggingface.co/jobs/byte-vortex/6a6ff5736b79c09949c200e4
-Downloading nvidia-nvshmem-cu13 (57.6MiB)
-Downloading numpy (15.9MiB)
-Downloading cuda-bindings (6.3MiB)
-Downloading nvidia-cufile (1.2MiB)
-Downloading sympy (6.0MiB)
-Downloading nvidia-cuda-runtime (2.1MiB)
-Downloading networkx (2.0MiB)
-Downloading nvidia-cublas (403.5MiB)
-Downloading triton (188.6MiB)
-Downloading nvidia-cusparse (139.2MiB)
-Downloading torch (502.2MiB)
-Downloading nvidia-cusparselt-cu13 (162.3MiB)
-Downloading nvidia-curand (56.8MiB)
-Downloading nvidia-nvjitlink (38.9MiB)
-Downloading nvidia-cufft (204.2MiB)
-Downloading nvidia-cusolver (191.6MiB)
-Downloading nvidia-nccl-cu13 (196.4MiB)
-Downloading nvidia-cudnn-cu13 (349.2MiB)
-Downloading nvidia-cuda-cupti (10.2MiB)
-Downloading nvidia-cuda-nvrtc (86.0MiB)
- 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-cublas
- Downloaded nvidia-cudnn-cu13
- Downloaded torch
-Installed 30 packages in 222ms
-======================================================================
-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_c2c6c6a643bb", "created_at": "2026-08-03T01:58:04+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_a81688fc4c68", "created_at": "2026-08-03T01:53:43+00:00", "title": "Not attempted. The official MAZero training recipe (which NonZero extends) targ…"}
+{"type": "markdown", "id": "cell_a6506bc1727b", "created_at": "2026-08-03T02:23:45+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_8c327e7535cb", "created_at": "2026-08-03T01:53:44+00:00", "title": "Not attempted. Same reasoning as Claim 5 -- SMACv2 has the same compute require…"}
+{"type": "markdown", "id": "cell_4f4bc8f81ffd", "created_at": "2026-08-03T02:23:46+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,43 +3,8 @@
 
 ---
 <!-- trackio-cell
-{"type": "artifact", "id": "cell_dc445e55519a", "created_at": "2026-08-03T01:53:45+00:00", "title": "Reproduction bundle (environment, surrogate, validation script, C++ patch)", "artifact": "nonzero-repro/repro-bundle:v1", "artifact_type": "dataset"}
+{"type": "artifact", "id": "cell_8088718eab2b", "created_at": "2026-08-03T02:23:47+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_41b739b9d8c4", "created_at": "2026-08-03T01:54:36+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_f763d79b3c3e", "created_at": "2026-08-03T01:57:03+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
-
-
----
-<!-- trackio-cell
-{"type": "markdown", "id": "cell_0f25ce87ab89", "created_at": "2026-08-03T01:58:04+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 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 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.
-
-## Scope & cost
-
-|  | This reproduction | Full replication |
-|---|---|---|
-| Scope | Claim 1 (verified, toy) + 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 4 toy result + infrastructure validated, full comparison not completed; Claims 2-3, 5-6 not attempted |

pages/executive-summary/page.md

@@ -3,7 +3,7 @@
 
 ---
 <!-- trackio-cell
-{"type": "markdown", "id": "cell_7e08479ac343", "created_at": "2026-08-03T01:53:46+00:00", "title": "Executive summary", "pinned": true, "pinned_at": "2026-08-03T01:53:47+00:00"}
+{"type": "markdown", "id": "cell_68176da7105c", "created_at": "2026-08-03T02:23:48+00:00", "title": "Executive summary", "pinned": true, "pinned_at": "2026-08-03T02:23:48+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.
 

workspace.json

@@ -3,22 +3,6 @@
   "file_count": 0,
   "total_size": 0,
   "files": [],
-  "hub_refs": [
-    {
-      "url": "https://huggingface.co/jobs/byte-vortex/6a6ff4e06b79c09949c200e0",
-      "type": "Jobs",
-      "label": "byte-vortex/6a6ff4e06b79c09949c200e0"
-    },
-    {
-      "url": "https://huggingface.co/jobs/byte-vortex/6a6ff5736b79c09949c200e4",
-      "type": "Jobs",
-      "label": "byte-vortex/6a6ff5736b79c09949c200e4"
-    },
-    {
-      "url": "https://huggingface.co/buckets/byte-vortex/nonzero-repro-artifacts",
-      "type": "Buckets",
-      "label": "byte-vortex/nonzero-repro-artifacts"
-    }
-  ],
+  "hub_refs": [],
   "reference_only": true
 }