Add reproducible MCE-220 Model A runner

Bundle the frozen MCE-220 dataset and audit trail, corrected Model A evaluation runner, pinned asset downloader, exact verifier, and hard-timeout supervisor.

README.md

@@ -0,0 +1,20 @@
+---
+tags:
+- peft
+- qwen3
+- entropy
+- theorem-proving
+- benchmark
+---
+
+# Entropy Inequality Prover models and scripts
+
+This repository contains the project checkpoints and inference resources. The new [MCE-220 Model A runner](./mce220_runner/) packages the corrected beam-search implementation, exact proof verifier, hard-timeout supervisor, frozen inference policy, and a complete local copy of the 220-question benchmark with its audit trail.
+
+## MCE-220 release
+
+- Runner and instructions: [`mce220_runner/`](./mce220_runner/)
+- Model A adapter: [`qwen-06b-sft-4type-old-format-lora-dataset-a-4096-balanced-higher-maxm/checkpoint-9534/`](./qwen-06b-sft-4type-old-format-lora-dataset-a-4096-balanced-higher-maxm/checkpoint-9534/)
+- Bundled benchmark: [`mce220_runner/dataset/`](./mce220_runner/dataset/)
+
+The downloader pins this model repository at `7fcfe778e1c36cd67e88ea8aa2ee761a50a39127` and the base model at `c1899de289a04d12100db370d81485cdf75e47ca`. Existing checkpoint directories are unchanged. Model and benchmark reuse terms have not yet been assigned; this card does not add a license.

mce220_runner/README.md

@@ -0,0 +1,54 @@
+# MCE-220 Model A runner
+
+This directory is a self-contained evaluation bundle for Model A checkpoint-9534 on the frozen 220-question MCE-220 benchmark. The benchmark, provenance, generation reports, validation evidence, diversity audit, generation configuration, runner, exact verifier, and supervision code are included here. Large model weights are downloaded on demand from immutable Hugging Face revisions.
+
+## Pinned inputs
+
+- Dataset source commit: `5650d7c8198a68116e8d12934aed41a37866ba92` (a byte-identical copy is under `dataset/`).
+- Model repository commit: `7fcfe778e1c36cd67e88ea8aa2ee761a50a39127`.
+- Model A adapter: `qwen-06b-sft-4type-old-format-lora-dataset-a-4096-balanced-higher-maxm/checkpoint-9534`.
+- Base model: `Qwen/Qwen3-0.6B` at `c1899de289a04d12100db370d81485cdf75e47ca`.
+
+`download_assets.py` downloads only the nine inference-required checkpoint files. It rejects optimizer, scheduler, RNG, trainer-state, and training-argument artifacts, verifies the adapter and tokenizer SHA-256 values, downloads the seven required base-model files, and compares the bundled dataset with the pinned dataset source.
+
+## Setup
+
+Linux with Bash, Python 3.10 or newer, CUDA, and NVIDIA GPUs is expected. Create an environment, install the CUDA-enabled PyTorch build suitable for the host, then install the remaining pinned requirements:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r mce220_runner/requirements.txt
+python mce220_runner/download_assets.py
+```
+
+If your platform needs a different PyTorch CUDA wheel, install that wheel first and then install the other pinned packages without replacing it. The base model is about 1.5 GB and the adapter about 162 MB. A worker holds an independent model instance; allow roughly 3–5 GiB of free VRAM per worker plus search overhead. The paper configuration uses eight workers. GPU IDs may be repeated only when a device has enough memory for multiple workers.
+
+## Commands
+
+```bash
+# Validate every asset and print the frozen 220-row command without loading a model.
+bash mce220_runner/run_mce220.sh dry-run --gpu-ids 0,1,2,3,4,5,6,7 --workers 8
+
+# Run one question with beam 4, one rollout, depth 4, and one GPU.
+bash mce220_runner/run_mce220.sh smoke --gpu-ids 0 --workers 1
+
+# Run all questions with the published search and hard-timeout policy.
+bash mce220_runner/run_mce220.sh full --gpu-ids 0,1,2,3,4,5,6,7 --workers 8 --output-dir ./mce220-results
+```
+
+Set `PYTHON` to choose the interpreter and `MCE220_ASSET_DIR` to place downloaded weights outside this directory.
+
+## Frozen full-run policy
+
+The full mode fixes beam size 32, six rollouts, maximum depth 24, seed 42, temperature 1.2, top-p 0.9, 2,048 generated tokens, 6,000 explored nodes, and a 1,000-second external hard timeout for every question. It uses the canonical raw prompt, candidate normalization, exact Shannon LP checks, and the pinned local base-model snapshot. The supervisor has a 42-hour total stop so interrupted jobs can be resumed deliberately.
+
+## Outputs and resume behavior
+
+`full` writes `results.jsonl`, `supervisor-state.json`, and immutable per-attempt manifests/stdout/stderr under `supervisor-attempts/`. Each successful or timed-out question produces one row, and proof-bearing rows are checked by the exact rational verifier. Re-running `full` with the same output directory validates the existing prefix and continues at the next question. It never silently replaces a nonempty result file. `smoke` similarly resumes a valid one-row prefix. Use a new output directory to start a clean run.
+
+## Limitations
+
+The benchmark contains constructed Shannon-type problems with supplied equality conditions; it does not cover arbitrary dense or non-Shannon inequalities. The base model and adapter are trusted local Hugging Face artifacts and the loader uses `trust_remote_code=True`, although the pinned Qwen revision contains no custom Python files. GPU sampling remains stochastic across kernels, devices, drivers, and library builds. A clean rerun follows the published protocol but is not guaranteed to reproduce exactly 155 proofs out of 220.
+
+No AITIP/PSITIP baseline, training code, or historical segmented runner is included. No license is asserted by this bundle.

mce220_runner/SOURCE_MANIFEST.json

@@ -0,0 +1,252 @@
+{
+  "created_utc": "2026-09-01T11:12:07.595478Z",
+  "files": {
+    "README.md": {
+      "bytes": 4249,
+      "sha256": "d7fb5484e254526cfca3476ef341fabcf14f34479f375ee8cb3416dc565aeaac",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "beam_search_model2/Data_Generation_via_LLM_Guided_Search_v12.py": {
+      "bytes": 97133,
+      "sha256": "403370fcb05db7fb515109c76a87eb67ccd7033fdb06544fe6b239138a21b393",
+      "source": {
+        "kind": "local-source",
+        "path": "beam_search_model2/Data_Generation_via_LLM_Guided_Search_v12.py"
+      }
+    },
+    "beam_search_model2/__init__.py": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "beam_search_model2/llm_api_compat.py": {
+      "bytes": 872,
+      "sha256": "8ed35fee37688c020051f13cf9945a402c8b1b969ca06acd204e629be9ed2cc0",
+      "source": {
+        "kind": "local-source",
+        "path": "beam_search_model2/llm_api_compat.py"
+      }
+    },
+    "beam_search_model2/llmstr_to_vector.py": {
+      "bytes": 3242,
+      "sha256": "0611db5d168460783755395b5a7aa4d95d78a8397139b53584eb5a17dc27c8ef",
+      "source": {
+        "kind": "local-source",
+        "path": "beam_search_model2/llmstr_to_vector.py"
+      }
+    },
+    "beam_search_model2/run_on_window_shear_jsonl_v12.py": {
+      "bytes": 30325,
+      "sha256": "197fd80b4dc39486e987b10547ed49a84fabf953e2ff6a2393b5c47cdadc95bf",
+      "source": {
+        "kind": "local-source",
+        "path": "beam_search_model2/run_on_window_shear_jsonl_v12.py"
+      }
+    },
+    "beam_search_model2/verify_proof_certificate.py": {
+      "bytes": 20711,
+      "sha256": "ba00337dac6e8715a8f4dd32166bb1393ec02e37ad931e9affdae7741807349a",
+      "source": {
+        "kind": "local-source",
+        "path": "beam_search_model2/verify_proof_certificate.py"
+      }
+    },
+    "data/__init__.py": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "data/entropy_vector_converter.py": {
+      "bytes": 9470,
+      "sha256": "3a1398661b146e661c91b2fa4d815a5e87b2a209751dba630ec6e88feb34d109",
+      "source": {
+        "kind": "local-source",
+        "path": "data/entropy_vector_converter.py"
+      }
+    },
+    "dataset/README.md": {
+      "bytes": 4651,
+      "sha256": "909828a43ace9c3d4e9aa2e2fe96812dadd1c08ece52c87cf4dc896ad4ce0452",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/audit/diversity-audit.json": {
+      "bytes": 8239,
+      "sha256": "56721eb34f35fa9acc2d81bbb13b0ea263a7f29bc8838372339dbc38ecda44a4",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/audit/generation-report.jsonl": {
+      "bytes": 69724,
+      "sha256": "50304ef59e263296d675bf63f79ceb04857deaba339bf7b491dca5d0752ca12c",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/audit/provenance.jsonl": {
+      "bytes": 4453377,
+      "sha256": "cbd708a699899127a254d7367df6f129fcc6eec73b50f05db86f01b5a732e189",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/audit/run-manifest.json": {
+      "bytes": 2750,
+      "sha256": "ac32fdaecf845714f9802c584c91b8743398898ff7e7c1f36c43014dea36d9a6",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/audit/validation-report.json": {
+      "bytes": 381,
+      "sha256": "3f86d1391c15a343cb938092a456ce2b5b88bb7f1ebcbf4089d0c8174c7e4d3c",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/data/questions.jsonl": {
+      "bytes": 499119,
+      "sha256": "1ff45298389fa9a0cc6000b833302d610c489334c88d40a07b28b45ea76c762a",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "dataset/generation/e2n_v2.toml": {
+      "bytes": 1560,
+      "sha256": "3346eb6fc6aa0bb70ca15f9a840d7b0f366418072c58cb76d32e0f8ac9faae4a",
+      "source": {
+        "kind": "dataset-snapshot",
+        "repo": "entropyinequalityprover/MCE-220",
+        "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+      }
+    },
+    "download_assets.py": {
+      "bytes": 8434,
+      "sha256": "f308777bcf46500d4ce8fe2636e0b957ec0c361dd74fc06416204ccb17538610",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "experiments/__init__.py": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "experiments/reviewer_response/__init__.py": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "experiments/reviewer_response/configs/inference_policy.toml": {
+      "bytes": 671,
+      "sha256": "ba4e6497f6e688a0740cfbcc945488c20a9f447084b3e05bde4bb08ef51e07fe",
+      "source": {
+        "kind": "local-source",
+        "path": "experiments/reviewer_response/configs/inference_policy.toml"
+      }
+    },
+    "experiments/reviewer_response/run_search_benchmark.py": {
+      "bytes": 40875,
+      "sha256": "7c3a442548089419d0c1f1af24d764474aee7f540a818bd3bb27db74c997c0bd",
+      "source": {
+        "change": "portable --base-model argument and effective-path recording",
+        "kind": "derived-local-source",
+        "path": "experiments/reviewer_response/run_search_benchmark.py"
+      }
+    },
+    "experiments/reviewer_response/supervise_search_benchmark.py": {
+      "bytes": 30678,
+      "sha256": "3a748d5651de33aedb93d1ae9bf396ba9cbf3e87a69dce45fea1edcb52137d96",
+      "source": {
+        "kind": "local-source",
+        "path": "experiments/reviewer_response/supervise_search_benchmark.py"
+      }
+    },
+    "grpo_pipeline/__init__.py": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "grpo_pipeline/modules/__init__.py": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "grpo_pipeline/modules/llm_api_interface.py": {
+      "bytes": 16629,
+      "sha256": "4e7bd0f8c13be24d4e09ea90270799cbc440015beb0575e314b5d659b2a7544e",
+      "source": {
+        "kind": "local-source",
+        "path": "grpo_pipeline/modules/llm_api_interface.py"
+      }
+    },
+    "requirements.txt": {
+      "bytes": 240,
+      "sha256": "cbfac9b9d0f3a38e9c1a4c361856fe9678d95c31cf0b895ecab06de544a85a25",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    },
+    "run_mce220.sh": {
+      "bytes": 5042,
+      "sha256": "fb3198e886fe53b09011344620da50b5734acd49e24ef147f8fe3e58f44f8959",
+      "source": {
+        "kind": "generated-release-file"
+      }
+    }
+  },
+  "pinned_revisions": {
+    "base_model": {
+      "repo": "Qwen/Qwen3-0.6B",
+      "revision": "c1899de289a04d12100db370d81485cdf75e47ca"
+    },
+    "dataset": {
+      "repo": "entropyinequalityprover/MCE-220",
+      "revision": "5650d7c8198a68116e8d12934aed41a37866ba92"
+    },
+    "model": {
+      "repo": "entropyinequalityprover/models_and_scripts",
+      "revision": "7fcfe778e1c36cd67e88ea8aa2ee761a50a39127"
+    }
+  },
+  "schema_version": "mce220-runner-source-manifest-v1",
+  "self_reference": {
+    "path": "SOURCE_MANIFEST.json",
+    "reason": "A file cannot contain its own cryptographic digest; verify this file from the release commit.",
+    "sha256": null
+  },
+  "source_workspace": {
+    "git_head": "985afadcface3883a66a1c0bcd39d141737abc1c",
+    "note": "Selected files were copied from the validated current worktree without modifying it."
+  }
+}

mce220_runner/beam_search_model2/Data_Generation_via_LLM_Guided_Search_v12.py

@@ -0,0 +1,2232 @@
+# This is for llm inference on 4type data trained llm model2.
+import random
+import os
+import sys
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from concurrent.futures.process import BrokenProcessPool
+import multiprocessing as mp
+
+import numpy as np
+import re
+from scipy.sparse import csr_matrix, vstack, hstack, coo_matrix
+from scipy.optimize import linprog
+from typing import List, Dict, Tuple, Optional
+import json
+import time
+import uuid
+import pickle
+# Make imports work when running from repo root (or anywhere)
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+_DATA_DIR = _REPO_ROOT / "data"
+_MODEL2_DIR = _REPO_ROOT / "beam_search_model2"
+for _p in (str(_DATA_DIR), str(_MODEL2_DIR)):
+    if _p not in sys.path:
+        sys.path.append(_p)
+
+try:
+    # Running as a script (local dir on sys.path)
+    from llmstr_to_vector import polym_ineq_to_vector
+    from entropy_vector_converter import string_to_vector, vector_to_string
+    from llm_api_compat import LLM as LLM_propose_inequalities
+    from llm_api_compat import get_last_llm_stats
+except ModuleNotFoundError:
+    # Fallback to absolute/package-style imports if needed
+    from beam_search_model2.llmstr_to_vector import polym_ineq_to_vector
+    from entropy_vector_converter import string_to_vector, vector_to_string
+    from beam_search_model2.llm_api_compat import LLM as LLM_propose_inequalities
+    from beam_search_model2.llm_api_compat import get_last_llm_stats
+
+# ---- Multi-GPU LLM worker pool support (one process per GPU; one model per process) ----
+_GPU_ADAPTER_PATH = None
+_GPU_USE_DUMMY = False
+_GPU_READY = False
+
+# Global cache for persistent GPU executors
+_CACHED_GPU_EXECUTORS = None
+_CACHED_GPU_PARAMS = None
+_CACHED_GAMMA = {}
+_COND_CACHE = {}
+_LAST_RUN_ID = None
+
+
+def _is_fatal_gpu_worker_exception(exc: BaseException) -> bool:
+    """Identify pool crashes and accelerator OOMs that must abort the run."""
+
+    current: BaseException | None = exc
+    seen: set[int] = set()
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        if isinstance(current, BrokenProcessPool):
+            return True
+        class_name = type(current).__name__.lower()
+        message = str(current).lower()
+        if "outofmemory" in class_name or any(
+            fragment in message
+            for fragment in (
+                "cuda out of memory",
+                "cuda error: out of memory",
+                "hip out of memory",
+                "cublas_status_alloc_failed",
+                "cudnn_status_alloc_failed",
+                "process in the process pool was terminated abruptly",
+            )
+        ):
+            return True
+        current = current.__cause__ or current.__context__
+    return False
+
+ALPHABET = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+_X_TOKEN_RE = re.compile(r"X_\{([^}]+)\}")
+_MULTIPLIER_PAREN_RE = re.compile(r"(\b\d+)\*\(")
+_HI_TERM_RE = re.compile(r"(?<![A-Za-z])[HI]\([^)]*\)")
+_SINGLE_POSITIVE_STEP_RE = re.compile(
+    r"^\+?(?:(\d*\.?\d+)\*?)?([HI]\([^()]*\))$"
+)
+
+def _use_alpha_prompt() -> bool:
+    return os.environ.get("BEAM_PROMPT_FORMAT", "alphabet").strip().lower() != "canonical"
+
+
+def _sort_alpha_groups_enabled() -> bool:
+    return os.environ.get("BEAM_SORT_ALPHA_GROUPS", "0").strip() == "1"
+
+
+def _normalize_candidates_enabled() -> bool:
+    return os.environ.get("BEAM_NORMALIZE_CANDIDATES", "0").strip() == "1"
+
+
+def _format_scalar_text(value: float) -> str:
+    rounded = round(value)
+    if abs(value - rounded) <= 1e-12:
+        return str(int(rounded))
+    return f"{value:.12g}"
+
+
+def _strip_wrapping_parens(expr: str) -> str:
+    s = (expr or "").strip()
+    while s.startswith("(") and s.endswith(")"):
+        depth = 0
+        wraps_all = True
+        for idx, ch in enumerate(s):
+            if ch == "(":
+                depth += 1
+            elif ch == ")":
+                depth -= 1
+                if depth < 0:
+                    return s
+                if depth == 0 and idx != len(s) - 1:
+                    wraps_all = False
+                    break
+        if depth != 0 or not wraps_all:
+            break
+        s = s[1:-1].strip()
+    return s
+
+
+def _split_top_level_linear_terms(expr: str) -> List[str]:
+    parts: List[str] = []
+    start = 0
+    depth = 0
+    for idx, ch in enumerate(expr):
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth -= 1
+        elif depth == 0 and idx > start and ch in "+-":
+            parts.append(expr[start:idx])
+            start = idx
+    parts.append(expr[start:])
+    return [p for p in parts if p]
+
+
+def _parse_linear_hi_term(term: str) -> Optional[Tuple[float, str]]:
+    s = _strip_wrapping_parens(term)
+    m = re.fullmatch(r"([+-]?)(?:(\d*\.?\d+)\*?)?([HI]\([^()]*\))", s)
+    if not m:
+        return None
+    sign_str, coeff_str, hi_term = m.groups()
+    coeff = 1.0
+    if coeff_str:
+        try:
+            coeff = float(coeff_str)
+        except ValueError:
+            return None
+    if sign_str == "-":
+        coeff *= -1.0
+    return coeff, hi_term
+
+
+def _distribute_scalar_over_hi_expr(expr: str, scalar: float) -> Optional[str]:
+    inner = _strip_wrapping_parens(expr)
+    if not inner:
+        return None
+    pieces = _split_top_level_linear_terms(inner)
+    if not pieces:
+        return None
+    scaled_terms: List[str] = []
+    for piece in pieces:
+        parsed = _parse_linear_hi_term(piece)
+        if parsed is None:
+            return None
+        coeff, hi_term = parsed
+        scaled_terms.append(f"{_format_scalar_text(scalar * coeff)}*{hi_term}")
+    return "".join(
+        term if idx == 0 or term.startswith("-") else f"+{term}"
+        for idx, term in enumerate(scaled_terms)
+    )
+
+
+def _collapse_leading_scalar_wrappers(expr: str) -> str:
+    s = _strip_wrapping_parens(expr)
+    while True:
+        m = re.fullmatch(r"([+-]?\d*\.?\d+)\*\((.*)\)", s)
+        if not m:
+            return s
+        try:
+            outer_coeff = float(m.group(1))
+        except ValueError:
+            return s
+        inner = _collapse_leading_scalar_wrappers(m.group(2))
+        distributed = _distribute_scalar_over_hi_expr(inner, outer_coeff)
+        if distributed is None:
+            return s
+        s = distributed
+
+
+def _build_alpha_mapping(exprs: List[str]) -> Tuple[Optional[Dict[int, str]], Optional[Dict[str, int]]]:
+    """
+    Build a deterministic mapping between indices and letters for alphabet syntax.
+    Returns (idx_to_letter, letter_to_idx) or (None, None) if not applicable.
+    """
+    indices: List[int] = []
+    for expr in exprs:
+        indices.extend(_extract_var_indices(expr))
+    unique = sorted(set(indices))
+    if not unique:
+        return None, None
+    if len(unique) > len(ALPHABET):
+        sys.stderr.write(
+            f"[beam_debug] Too many unique indices ({len(unique)}) for alphabet mapping; "
+            "falling back to numeric syntax.\n"
+        )
+        sys.stderr.flush()
+        return None, None
+    idx_to_letter = {idx: ALPHABET[i] for i, idx in enumerate(unique)}
+    letter_to_idx = {v: k for k, v in idx_to_letter.items()}
+    return idx_to_letter, letter_to_idx
+
+
+def _convert_old_to_alpha(expr: str, idx_to_letter: Optional[Dict[int, str]]) -> str:
+    if not expr or not idx_to_letter:
+        return expr
+    s = _normalize_to_braces(expr)
+    sort_groups = _sort_alpha_groups_enabled()
+
+    def repl(match: re.Match) -> str:
+        parts = [p.strip() for p in match.group(1).split(",")]
+        letters = []
+        for part in parts:
+            if not part.isdigit():
+                letters.append(part)
+                continue
+            letters.append(idx_to_letter.get(int(part), part))
+        if sort_groups:
+            letters = sorted(letters)
+        return "".join(letters)
+
+    s = _X_TOKEN_RE.sub(repl, s)
+    s = _MULTIPLIER_PAREN_RE.sub(r"\1(", s)
+    return s
+
+
+def _convert_alpha_group(text: str, letter_to_idx: Dict[str, int]) -> str:
+    if "X_" in text:
+        return text
+    letters = re.findall(r"[A-Z]", text)
+    if not letters:
+        return text
+    if _sort_alpha_groups_enabled():
+        letters = sorted(letters)
+    indices = []
+    for ch in letters:
+        if ch not in letter_to_idx:
+            return text
+        indices.append(str(letter_to_idx[ch]))
+    return "X_{" + ",".join(indices) + "}"
+
+
+def _convert_alpha_term(term: str, letter_to_idx: Dict[str, int]) -> str:
+    if term.startswith("H(") and term.endswith(")"):
+        inner = term[2:-1]
+        if "|" in inner:
+            left, right = inner.split("|", 1)
+            return f"H({_convert_alpha_group(left, letter_to_idx)}|{_convert_alpha_group(right, letter_to_idx)})"
+        return f"H({_convert_alpha_group(inner, letter_to_idx)})"
+    if term.startswith("I(") and term.endswith(")"):
+        inner = term[2:-1]
+        if "|" in inner:
+            main, cond = inner.split("|", 1)
+        else:
+            main, cond = inner, None
+        if ";" in main:
+            left, right = main.split(";", 1)
+        else:
+            left, right = main, ""
+        left_conv = _convert_alpha_group(left, letter_to_idx)
+        right_conv = _convert_alpha_group(right, letter_to_idx)
+        if cond is not None:
+            cond_conv = _convert_alpha_group(cond, letter_to_idx)
+            return f"I({left_conv};{right_conv}|{cond_conv})"
+        return f"I({left_conv};{right_conv})"
+    return term
+
+
+def _convert_alpha_to_old(expr: str, letter_to_idx: Optional[Dict[str, int]]) -> str:
+    if not expr or not letter_to_idx:
+        return expr
+    s = _HI_TERM_RE.sub(lambda m: _convert_alpha_term(m.group(0), letter_to_idx), expr)
+    s = re.sub(r"(\b\d+)\(", r"\1*(", s)
+    return s
+
+
+def _sort_alpha_group_text(text: str) -> str:
+    raw = text.strip()
+    if not raw or "X_" in raw:
+        return raw
+    letters = re.findall(r"[A-Z]", raw)
+    if not letters:
+        return raw
+    leftover = re.sub(r"[A-Z\s]", "", raw)
+    if leftover:
+        return raw
+    return "".join(sorted(letters))
+
+
+def _canonicalize_alpha_term_text(term: str) -> str:
+    if term.startswith("H(") and term.endswith(")"):
+        inner = term[2:-1]
+        if "|" in inner:
+            left, right = inner.split("|", 1)
+            return f"H({_sort_alpha_group_text(left)}|{_sort_alpha_group_text(right)})"
+        return f"H({_sort_alpha_group_text(inner)})"
+    if term.startswith("I(") and term.endswith(")"):
+        inner = term[2:-1]
+        if "|" in inner:
+            main, cond = inner.split("|", 1)
+        else:
+            main, cond = inner, None
+        if ";" in main:
+            left, right = main.split(";", 1)
+        else:
+            left, right = main, ""
+        left = _sort_alpha_group_text(left)
+        right = _sort_alpha_group_text(right)
+        if cond is not None:
+            return f"I({left};{right}|{_sort_alpha_group_text(cond)})"
+        return f"I({left};{right})"
+    return term
+
+
+def _normalize_candidate_text(cand_raw: str) -> str:
+    s = cand_raw.strip().strip("`").strip()
+    if not s:
+        return s
+    s = re.sub(r"^```[a-zA-Z0-9_-]*\s*", "", s)
+    s = re.sub(r"\s*```$", "", s)
+    s = re.sub(r"^\s*(?:try|candidate|answer|output|step)\s*:\s*", "", s, flags=re.IGNORECASE)
+    s = re.sub(r"^\s*(?:[*]|(\d+)[\.\)]|-(?:\s+|$))\s*", "", s).strip()
+    if s.lower() == "wrong":
+        return "wrong"
+    first_math = re.search(r"[HI]\(", s)
+    if first_math and first_math.start() > 0:
+        prefix = s[: first_math.start()]
+        if ":" in prefix or re.search(r"[A-Za-z]", prefix):
+            s = s[first_math.start() :].strip()
+    s = re.split(r"\bbecause\b", s, maxsplit=1, flags=re.IGNORECASE)[0].strip()
+    s = re.sub(r"\s+", "", s)
+    s = re.sub(r">\s*=\s*0\b", ">=0", s)
+    s = re.sub(r"<\s*=\s*0\b", "<=0", s)
+    s = re.sub(r"(?<![<>])=\s*0\b", "=0", s)
+    s = re.sub(r">\s*0\b", ">=0", s)
+    s = re.sub(r"\(\s*", "(", s)
+    s = re.sub(r"\s*\)", ")", s)
+    s = re.sub(r"\s*;\s*", ";", s)
+    s = re.sub(r"\s*\|\s*", "|", s)
+    s = re.sub(r"\s*,\s*", ",", s)
+    s = re.sub(r"\s*\+\s*", "+", s)
+    s = re.sub(r"\s*-\s*", "-", s)
+    s = re.sub(r"\s*\*\s*", "*", s)
+    # 若缺少比較運算子，自動補齊 >=0
+    if not any(op in s for op in [">=0", ">0", "<=0", "=0"]):
+        s += ">=0"
+    
+    # 補全未閉合的括號 (Auto-balance parentheses before the comparator)
+    for op in [">=0", ">0", "<=0", "=0"]:
+        if op in s:
+            lhs, rhs = s.split(op, 1)
+            open_p = lhs.count("(")
+            close_p = lhs.count(")")
+            if open_p > close_p:
+                lhs += ")" * (open_p - close_p)
+            lhs = _collapse_leading_scalar_wrappers(lhs)
+            s = lhs + op + rhs
+            break
+
+    if _sort_alpha_groups_enabled():
+        s = _HI_TERM_RE.sub(lambda m: _canonicalize_alpha_term_text(m.group(0)), s)
+    return s
+
+
+def _empty_llm_usage() -> Dict[str, int]:
+    return {
+        "llm_calls": 0,
+        "prompt_tokens_total": 0,
+        "generated_tokens_total": 0,
+        "generated_sequences_total": 0,
+        "extracted_candidates_total": 0,
+        "format_fail_total": 0,
+    }
+
+
+def _merge_llm_usage(dst: Dict[str, int], src: Optional[Dict]) -> None:
+    if not src:
+        return
+    dst["llm_calls"] += 1
+    dst["prompt_tokens_total"] += int(src.get("prompt_tokens", 0) or 0)
+    dst["generated_tokens_total"] += int(src.get("generated_tokens_total", 0) or 0)
+    dst["generated_sequences_total"] += int(src.get("num_sequences", 0) or 0)
+    dst["extracted_candidates_total"] += int(src.get("extracted_candidates", 0) or 0)
+
+
+def _split_candidate_comparator(cand: str) -> Tuple[str, Optional[str]]:
+    s = (cand or "").strip()
+    match = re.search(r"(>=|<=|>|<|=)\s*0\s*$", s)
+    if match:
+        comparator = {
+            ">=": ">=0",
+            "<=": "<=0",
+            ">": ">0",
+            "<": "<0",
+            "=": "=0",
+        }[match.group(1)]
+        return s[: match.start()].strip(), comparator
+    return s, None
+
+
+def _normalize_constraint_comparator(expr: str, *, add_default: bool = False) -> str:
+    """Canonicalize a comparator, weakening strict inequalities safely."""
+    raw = (expr or "").strip()
+    lhs, comparator = _split_candidate_comparator(raw)
+    if comparator == ">0":
+        comparator = ">=0"
+    elif comparator == "<0":
+        comparator = "<=0"
+    if comparator is None:
+        return f"{lhs}>=0" if add_default else lhs
+    return f"{lhs}{comparator}"
+
+
+def _condition_comparator_allows_candidate(
+    cond_comparator: Optional[str],
+    cand_comparator: Optional[str],
+) -> bool:
+    if cond_comparator == "=0":
+        return cand_comparator in {"=0", ">=0"}
+    return cond_comparator == ">=0" and cand_comparator == ">=0"
+
+
+def _is_positive_scalar_multiple(vec_a: csr_matrix, vec_b: csr_matrix, tol: float = 1e-9) -> bool:
+    a = vec_a.tocsr(copy=True)
+    b = vec_b.tocsr(copy=True)
+    a.sum_duplicates()
+    b.sum_duplicates()
+    a.sort_indices()
+    b.sort_indices()
+
+    if a.nnz == 0 or b.nnz == 0 or a.nnz != b.nnz:
+        return False
+    if not np.array_equal(a.indices, b.indices):
+        return False
+
+    a_data = np.asarray(a.data, dtype=float)
+    b_data = np.asarray(b.data, dtype=float)
+    if np.any(np.abs(b_data) <= tol):
+        return False
+
+    ratio = a_data[0] / b_data[0]
+    if ratio <= tol:
+        return False
+
+    return np.allclose(a_data, ratio * b_data, rtol=1e-9, atol=tol)
+
+
+def _is_scalar_multiple(vec_a: csr_matrix, vec_b: csr_matrix) -> bool:
+    return _is_positive_scalar_multiple(vec_a, vec_b) or _is_positive_scalar_multiple(vec_a, -vec_b)
+
+
+def _vectors_are_opposites(vec_a: csr_matrix, vec_b: csr_matrix, tol: float = 1e-9) -> bool:
+    return _is_positive_scalar_multiple(vec_a, -vec_b, tol=tol)
+
+
+def _parse_condition_constraints(
+    cond_lines: Optional[List[str]], n: int
+) -> List[Tuple[str, csr_matrix]]:
+    """Parse conditions once, promoting literal and two-sided equalities."""
+    equalities: List[csr_matrix] = []
+    inequalities: List[csr_matrix] = []
+    for raw in cond_lines or []:
+        condition = _normalize_constraint_comparator((raw or "").strip(), add_default=True)
+        if not condition or condition in {"(none)>=0", "NONE>=0", "NONE=0"}:
+            continue
+        _, comparator = _split_candidate_comparator(condition)
+        try:
+            vec = parse_cand_to_vector(condition, n)
+        except Exception:
+            continue
+        if vec is None or vec.nnz == 0:
+            continue
+        if comparator == "<=0":
+            vec = -vec
+            comparator = ">=0"
+        if comparator == "=0":
+            equalities.append(vec)
+        elif comparator == ">=0":
+            inequalities.append(vec)
+
+    paired = set()
+    for left in range(len(inequalities)):
+        if left in paired:
+            continue
+        for right in range(left + 1, len(inequalities)):
+            if right not in paired and _vectors_are_opposites(inequalities[left], inequalities[right]):
+                equalities.append(inequalities[left])
+                paired.update({left, right})
+                break
+
+    return [("eq", vec) for vec in equalities] + [
+        ("ge", vec) for idx, vec in enumerate(inequalities) if idx not in paired
+    ]
+
+
+def _parse_condition_matrices(
+    cond_lines: Optional[List[str]], n: int
+) -> Tuple[Optional[csr_matrix], Optional[csr_matrix]]:
+    constraints = _parse_condition_constraints(cond_lines, n)
+    eq_vecs = [vec for kind, vec in constraints if kind == "eq"]
+    ge_vecs = [vec for kind, vec in constraints if kind == "ge"]
+    return (
+        vstack(eq_vecs).tocsr() if eq_vecs else None,
+        vstack(ge_vecs).tocsr() if ge_vecs else None,
+    )
+
+
+def _is_condition_positive_multiple_step(cand: str, n: Optional[int], cond_lines: Optional[List[str]]) -> bool:
+    if n is None or not cond_lines:
+        return False
+
+    cand = _normalize_constraint_comparator(cand)
+    _, cand_comparator = _split_candidate_comparator(cand)
+    if cand_comparator is None:
+        return False
+
+    try:
+        cand_vec = parse_cand_to_vector(cand, n)
+    except Exception:
+        return False
+    if cand_vec is None or cand_vec.nnz == 0:
+        return False
+
+    for kind, cond_vec in _parse_condition_constraints(cond_lines, n):
+        cond_comparator = "=0" if kind == "eq" else ">=0"
+        if not _condition_comparator_allows_candidate(cond_comparator, cand_comparator):
+            continue
+        if kind == "eq" and _is_scalar_multiple(cand_vec, cond_vec):
+            return True
+        if kind == "ge" and _is_positive_scalar_multiple(cand_vec, cond_vec):
+            return True
+    return False
+
+
+def _strict_step_format_reason(
+    cand: str,
+    *,
+    n: Optional[int] = None,
+    cond_lines: Optional[List[str]] = None,
+) -> Optional[str]:
+    """
+    Accept only one positive H(...) or I(...) term with a trailing comparator.
+    Also accept multi-term outputs that are a positive scalar multiple of one
+    provided condition, e.g. 2*(cond)>=0 or cond>=0.
+    """
+    s = _normalize_constraint_comparator((cand or "").strip())
+    if not s:
+        return "empty"
+
+    lhs, comparator = _split_candidate_comparator(s)
+    if comparator is None:
+        return "missing_comparator"
+    if comparator == "<=0":
+        return "nonpositive_comparator"
+    lhs = lhs.strip()
+    if not lhs:
+        return "empty_lhs"
+
+    hi_term_count = len(_HI_TERM_RE.findall(lhs))
+    if hi_term_count == 1:
+        m = _SINGLE_POSITIVE_STEP_RE.fullmatch(lhs)
+        if m:
+            coeff_str = m.group(1)
+            if coeff_str is not None:
+                try:
+                    if float(coeff_str) <= 0:
+                        return "nonpositive_coeff"
+                except ValueError:
+                    return "bad_coeff"
+            if comparator == ">=0":
+                return None
+            # A Shannon atom is universally nonnegative, not universally zero.
+            # Equality output is allowed only when it matches a semantic
+            # equality condition in the condition-specific check below.
+            base_reason = "unjustified_equality"
+        else:
+            base_reason = "not_single_hi_term"
+    else:
+        base_reason = "multiple_terms"
+
+    if _is_condition_positive_multiple_step(s, n, cond_lines):
+        return None
+    return base_reason
+
+
+def _get_cond_matrix_for_run(run_id, n, cond_lines):
+    """
+    Worker-local cache.
+    Cache is valid only within the same run_id (i.e., one tree_search call).
+    """
+    global _COND_CACHE, _LAST_RUN_ID
+
+    if run_id != _LAST_RUN_ID:
+        _COND_CACHE.clear()
+        _LAST_RUN_ID = run_id
+
+    if not cond_lines:
+        return None, None
+
+    key = (n, tuple(cond_lines))
+    cached = _COND_CACHE.get(key)
+    if cached is not None:
+        return cached
+
+    res = _parse_condition_matrices(cond_lines, n)
+    _COND_CACHE[key] = res
+    return res
+
+def _generate_elemental_generators(n: int, dtype=np.int8) -> List[csr_matrix]:
+    """
+    Generate elemental Shannon-type inequalities for n variables:
+      1) H(X | others) >= 0
+      2) I(X;Y | Z) >= 0 for all pairs (X,Y) and all Z subset of remaining vars.
+    Return format matches existing code: [A], where A is csr_matrix (#ineq, 2^n-1).
+
+    Number of inequalities = n + C(n,2)*2^(n-2)
+    Complexity ~ O(n^2 * 2^n), much smaller than O(5^n).
+    """
+    if n in _CACHED_GAMMA:
+        return _CACHED_GAMMA[n]
+
+    # Use a different filename to avoid clashing with exhaustive ones
+    pkl_path = _MODEL2_DIR / f"elemental_generators_n{n}.pkl"
+    if pkl_path.exists():
+        try:
+            with open(pkl_path, "rb") as f:
+                gamma = pickle.load(f)          # expects [A]
+                _CACHED_GAMMA[n] = gamma
+                sys.stderr.write(f"[beam_debug] Loaded precomputed elemental generators for n={n} from {pkl_path}\n")
+                sys.stderr.flush()
+                return gamma
+        except Exception as e:
+            sys.stderr.write(f"[beam_debug] Failed to load {pkl_path}: {e}\n")
+            sys.stderr.flush()
+
+    sys.stderr.write(f"[beam_debug] Generating elemental generators for n={n}...\n")
+    sys.stderr.flush()
+
+    A, _b = elemental_inequalities_sparse(n, dtype=dtype)  # A is csr
+    gamma = [A]
+    _CACHED_GAMMA[n] = gamma
+
+    # Save to disk
+    try:
+        with open(pkl_path, "wb") as f:
+            pickle.dump(gamma, f, protocol=pickle.HIGHEST_PROTOCOL)
+            sys.stderr.write(f"[beam_debug] Saved elemental generators for n={n} to {pkl_path}\n")
+            sys.stderr.flush()
+    except Exception as e:
+        sys.stderr.write(f"[beam_debug] Failed to save {pkl_path}: {e}\n")
+        sys.stderr.flush()
+
+    return gamma
+
+
+def elemental_inequalities_sparse(n: int, dtype=np.int8):
+    """
+    Generate basic Shannon-type information measure inequality matrix.
+    """
+    m = (1 << n) - 1  # Number of columns (entropy variables)
+    rows = []
+    cols = []
+    data = []
+
+    def add_coeff(row_id: int, mask: int, val: int):
+        cols.append(mask - 1)  # 0-based
+        rows.append(row_id)
+        data.append(val)
+
+    row_id = 0
+    # H(X|Z) >= 0
+    for x in range(n):
+        # X mask
+        Xmask = 1 << x
+        # Z mask (everything else)
+        Zmask = ((1 << n) - 1) & (~Xmask)
+
+        # Add H(X|Z) >= 0 -> H(X U Z) - H(Z) >= 0
+        add_coeff(row_id, Xmask | Zmask, +1)
+        if Zmask != 0:
+            add_coeff(row_id, Zmask, -1)
+        row_id += 1
+
+    # I(X;Y|Z) >= 0
+    for x in range(n):
+        for y in range(x + 1, n):
+            zmask = 0
+            while zmask < (1 << n):
+                if (zmask & (1 << x)) == 0 and (zmask & (1 << y)) == 0:
+                    XZ = zmask | (1 << x)
+                    YZ = zmask | (1 << y)
+                    XYZ = zmask | (1 << x) | (1 << y)
+                    add_coeff(row_id, XZ, +1)
+                    add_coeff(row_id, YZ, +1)
+                    add_coeff(row_id, XYZ, -1)
+                    if zmask != 0:
+                        add_coeff(row_id, zmask, -1)
+                    row_id += 1
+                zmask += 1
+                if (zmask & (1 << x)) != 0:
+                    zmask += (1 << x)
+                if (zmask & (1 << y)) != 0:
+                    zmask += (1 << y)
+
+    # Build sparse matrix A and b
+    A = coo_matrix((np.array(data, dtype=dtype), (np.array(rows), np.array(cols))),
+                   shape=(max(rows) + 1, m)).tocsr()
+    b = np.zeros(A.shape[0], dtype=float)
+    return A, b
+
+
+def _beam_debug_print_M(*, depth: int, rollout: int, path_exprs: List[str], residual_vec, action: str) -> None:
+    """
+    Debug-print the current residual and path that will be used in the LP solve/enqueue.
+    """
+    try:
+        m_sz = len(path_exprs) if path_exprs else 0
+        residual_str = vector_to_string(residual_vec)
+        
+        sys.stderr.write(
+            f"[beam_debug] {action}: depth={depth} rollout={rollout} "
+            f"Path_size={m_sz} Residual={residual_str}\n"
+        )
+        sys.stderr.flush()
+    except Exception:
+        pass
+
+
+# def _get_residual_score(vec: csr_matrix) -> float:
+#     """
+#     Score a residual vector: smaller is better (shorter/simpler expression).
+#     Primary: number of terms (nnz).
+#     Secondary: sum of absolute coefficients.
+#     """
+#     if vec is None:
+#         return 999999.0
+#     # nnz is the number of non-zero joint entropy terms
+#     num_terms = vec.nnz
+#     # sum of absolute coefficients
+#     coeff_sum = np.sum(np.abs(vec.data)) if vec.nnz > 0 else 0
+#     return float(num_terms) * 1000.0 + float(coeff_sum)
+
+def _get_residual_score(vec: csr_matrix) -> float:
+    """
+    Score a residual vector for beam pruning: smaller is better.
+    Priority:
+      1) fewer terms (sparser expression),
+      2) smaller absolute magnitude on negative coefficients,
+      3) smaller overall absolute magnitude.
+    """
+    if os.environ.get("BEAM_RANDOM_SCORE", "0") == "1":
+        return random.random()
+
+    if vec is None or vec.nnz == 0:
+        return 0.0
+
+    coeffs = np.asarray(vec.data, dtype=np.float64)
+    neg_abs_sum = float(np.abs(coeffs[coeffs < 0]).sum()) if np.any(coeffs < 0) else 0.0
+    return  neg_abs_sum * 1e3
+
+
+def _select_beam_nodes(nodes, beam_size: int, *, random_prune: bool, rng=None):
+    """Return uniformly sampled or score-ranked kept nodes and their complement."""
+    if beam_size <= 0 or len(nodes) <= beam_size:
+        return list(nodes), []
+    if random_prune:
+        rng = rng or random.Random()
+        kept_indices = set(rng.sample(range(len(nodes)), beam_size))
+        kept = [node for idx, node in enumerate(nodes) if idx in kept_indices]
+        pruned = [node for idx, node in enumerate(nodes) if idx not in kept_indices]
+        return kept, pruned
+
+    ranked = sorted(nodes, key=lambda node: _get_residual_score(node.residual_vec))
+    return ranked[:beam_size], ranked[beam_size:]
+
+
+def _is_obviously_negative(vec: csr_matrix) -> bool:
+    """
+    Check if all coefficients are non-positive and at least one is strictly negative.
+    Returns True if the residual can never reach 0 by subtracting non-negative inequalities.
+    """
+    if vec is None or vec.nnz == 0:
+        return False
+    # Use a small epsilon for float precision
+    eps = 1e-9
+    # If any coefficient is significantly positive, it's not 'obviously negative'
+    if np.any(vec.data > eps):
+        return False
+    # If we are here, all coefficients are <= eps. 
+    # Check if at least one is significantly negative.
+    return np.any(vec.data < -eps)
+
+
+def _is_invalid_negative_ineq(
+    cand: str,
+    *,
+    n: Optional[int] = None,
+    cond_lines: Optional[List[str]] = None,
+) -> bool:
+    """
+    Check if the candidate is a negative term asserted as >= 0.
+    In Information Theory, terms like -I(X;Y) >= 0 are only valid if they are actually 0.
+    The training data uses -I(...) = 0.
+    """
+    s = cand.strip()
+    if ">=" in s and s.lstrip().startswith("-"):
+        if n is not None and cond_lines and _is_condition_positive_multiple_step(s, n, cond_lines):
+            return False
+        return True
+    return False
+
+
+def _is_in_row_space(vec: csr_matrix, matrix: Optional[csr_matrix]) -> bool:
+    """
+    Check if vec is a linear combination of the rows of matrix.
+    Uses linprog to solve matrix.T @ y = vec.T
+    """
+    if vec.nnz == 0:
+        return True
+    if matrix is None or matrix.shape[0] == 0:
+        return False
+    
+    try:
+        # Solve A_eq @ y = b_eq
+        # where A_eq is matrix.T and b_eq is vec.T
+        A_eq = matrix.toarray().T
+        b_eq = vec.toarray().flatten()
+        c = np.zeros(A_eq.shape[1])
+        # Bayesian coefficients can be negative, so bounds=(None, None)
+        res = linprog(c, A_eq=A_eq, b_eq=b_eq, bounds=(None, None), method='highs')
+        return res.success
+    except Exception:
+        return False
+
+
+def _get_involved_vars(vec: csr_matrix) -> set:
+    involved_vars = set()
+    if vec is None:
+        return involved_vars
+    for idx in vec.indices:
+        subset_idx = idx + 1
+        v = 1
+        temp = subset_idx
+        while temp > 0:
+            if temp & 1:
+                involved_vars.add(v)
+            temp >>= 1
+            v += 1
+    return involved_vars
+
+
+def _reduce_vector(vec: csr_matrix, mapping: Dict[int, int], num_vars: int) -> csr_matrix:
+    new_indices = []
+    for idx in vec.indices:
+        subset_idx = idx + 1
+        new_subset_idx = 0
+        for old_v, new_v in mapping.items():
+            if subset_idx & (1 << (old_v - 1)):
+                new_subset_idx |= (1 << (new_v - 1))
+        new_indices.append(new_subset_idx - 1)
+    new_dim = (1 << num_vars) - 1
+    return csr_matrix((vec.data, new_indices, [0, len(vec.data)]), shape=(1, new_dim))
+
+
+def _check_shannon_status(vec: csr_matrix, n_sample: int, Gamma: Optional[List[csr_matrix]] = None,
+                          cond_eq_matrix: Optional[csr_matrix] = None,
+                          cond_ge_matrix: Optional[csr_matrix] = None,
+                          max_vars_for_lp: int = 0,
+                          debug: bool = False) -> int:
+    """
+    Check whether the residual has a direct certificate or is flagged by the
+    numerical LP false-pruning heuristic.
+
+    In exact arithmetic, an unbounded minimization supplies a counterexample
+    ray.  This implementation trusts floating-point HiGHS status and does not
+    independently verify that ray, so the result can affect search completeness
+    but is never used to accept a proof. LP optimality likewise does not
+    terminate search because this routine does not reconstruct an explicit
+    conic certificate.
+    Returns:
+      1  if directly proved (nearly zero or all coefficients nonnegative)
+      0  if unknown, including an LP-true result without an explicit certificate
+      -1 if impossible (False/Prune) - only if n_sample <= max_vars_for_lp
+    """
+    if vec is None:
+        return 0
+
+    eps = 1e-9
+
+    # 1. Quick checks (Proved)
+    if vec.nnz > 0 and np.all(vec.data >= -eps):
+        return 1
+    if vec.nnz == 0 or np.allclose(vec.toarray(), 0, atol=eps):
+        return 1
+
+    if max_vars_for_lp > 0:
+        involved_res = _get_involved_vars(vec)
+
+        # Determine if we can do a full check (with conditions) or only a partial check (proved-only)
+        can_prune = (n_sample <= max_vars_for_lp)
+
+        # involved_vars for the LP context
+        if can_prune:
+            involved = set(range(1, n_sample + 1))
+        else:
+            # For n_sample > max_vars_for_lp (e.g. 6), we can only prove it if the residual variables fit in max_vars_for_lp
+            involved = involved_res
+            if len(involved) > max_vars_for_lp:
+                return 0
+            # If we are here, we are doing a "no-conditions" check to see if it's Shannon-true
+            cond_eq_matrix = None
+            cond_ge_matrix = None
+
+        num_vars = len(involved)
+        if num_vars == 0: return 0
+
+        # Select or generate Gamma
+        global _CACHED_GAMMA
+        if num_vars not in _CACHED_GAMMA:
+            _generate_elemental_generators(num_vars)
+        gamma_data = _CACHED_GAMMA[num_vars]
+        # Handle cached tuple format: ([A], names)
+        current_gamma = gamma_data[0] if isinstance(gamma_data, tuple) else gamma_data
+
+        if debug:
+            try:
+                type_str = "full" if can_prune else "residual-only"
+                sys.stderr.write(
+                    f"[beam_debug] LP_check_start: n={num_vars} ({type_str}) vec={vector_to_string(vec)}\n")
+                sys.stderr.flush()
+            except:
+                pass
+
+        sorted_vars = sorted(list(involved))
+        mapping = {old: new for new, old in enumerate(sorted_vars, 1)}
+        vec_small = _reduce_vector(vec, mapping, num_vars)
+
+
+        try:
+            G = vstack(current_gamma)  # shape: (num_gen, m)
+            c = vec_small.toarray().ravel()  # shape: (m,)
+
+            # A_ub @ y <= b_ub
+            # Shannon inequalities: G @ y >= 0 => -G @ y <= 0
+            A_ub_list = [-G]
+            
+            if cond_ge_matrix is not None and cond_ge_matrix.shape[0] > 0:
+                ge_small_list = []
+                for i in range(cond_ge_matrix.shape[0]):
+                    ge_reduced = _reduce_vector(cond_ge_matrix[i], mapping, num_vars)
+                    ge_small_list.append(-ge_reduced) # v @ y >= 0 => -v @ y <= 0
+                A_ub_list.append(vstack(ge_small_list))
+            
+            A_ub = vstack(A_ub_list)
+            b_ub = np.zeros(A_ub.shape[0], dtype=float)
+
+            A_eq = None
+            b_eq = None
+            if cond_eq_matrix is not None and cond_eq_matrix.shape[0] > 0:
+                cond_small_list = []
+                for i in range(cond_eq_matrix.shape[0]):
+                    c_reduced = _reduce_vector(cond_eq_matrix[i], mapping, num_vars)  # (1, m)
+                    cond_small_list.append(c_reduced)
+                A_eq = vstack(cond_small_list)  # shape: (num_cond, m)
+                b_eq = np.zeros(A_eq.shape[0], dtype=float)
+
+            # y is free (IMPORTANT)
+            bounds = [(None, None)] * G.shape[1]
+
+            res = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq,
+                          bounds=bounds, method="highs")
+
+            if res.status == 3:
+                # Numerically unbounded. In exact arithmetic this means the
+                # residual is false over the constrained Shannon outer cone.
+                if debug:
+                    sys.stderr.write("[beam_debug] lp_dual: numerically UNBOUNDED => false-prune\n")
+                    sys.stderr.flush()
+                return -1 if can_prune else 0
+
+            if res.status == 0 and res.success:
+                # optimal => should be ~0 => TRUE
+                if debug:
+                    sys.stderr.write(f"[beam_debug] lp_dual: OPTIMAL fun={res.fun}\n")
+                    sys.stderr.flush()
+
+                # res.fun might be -1e-12 numerically, treat as 0
+                if res.fun < -eps:
+                    # Theoretically this means it should be unbounded but solver didn't report it
+                    return -1 if can_prune else 0
+
+                return 0
+
+            # Other cases: iteration limit/numerical issues (unsafe to prune)
+            if debug:
+                sys.stderr.write(f"[beam_debug] lp_dual: status={res.status} msg={res.message}\n")
+                sys.stderr.flush()
+            return 0
+
+        except Exception as e:
+            if debug:
+                sys.stderr.write(f"[beam_debug] LP error: {e}\n")
+            return 0
+
+    return 0
+
+
+def _is_positive_polymatroid(vec: csr_matrix, n_sample: int, Gamma: Optional[List[csr_matrix]] = None, 
+                             cond_eq_matrix: Optional[csr_matrix] = None, 
+                             cond_ge_matrix: Optional[csr_matrix] = None,
+                             max_vars_for_lp: int = 0, debug: bool = False) -> bool:
+    """
+    Check if the residual is a positive polymatroid (Shannon inequality).
+    Returns True if vec >= 0 is already proved or follows from Gamma.
+    """
+    return _check_shannon_status(vec, n_sample, Gamma, cond_eq_matrix, cond_ge_matrix, max_vars_for_lp, debug) == 1
+
+
+def _normalize_to_braces(s: str) -> str:
+    """
+    Ensure all H(...) and I(...) terms use X_{...} notation.
+    Example: H(X_1,2) -> H(X_{1,2}), I(X_1;X_2) -> I(X_{1};X_{2}).
+    """
+    def repl_X(m):
+        inside = m.group(1)
+        if inside.startswith('{') and inside.endswith('}'):
+            return m.group(0)
+        # Split by comma to handle X_1,2
+        parts = [p.strip() for p in inside.split(',') if p.strip()]
+        return "X_{" + ",".join(parts) + "}"
+
+    # Replace all occurrences of X_ followed by digits/commas OR X_{...}
+    return re.sub(r'X_(\{?[0-9,]+\}?)', repl_X, s)
+
+
+def parse_cand_to_vector(cand: str, n: int) -> csr_matrix:
+    """
+    Robustly parse an inequality candidate string from the LLM into a vector.
+    Handles coefficients (including 8*H(...) or 8H(...)), signs, and conditional terms.
+    """
+    # 1. Strip comparator and all whitespace/asterisks
+    s = _strip_comparator(cand).replace(" ", "").replace("*", "")
+    
+    # 2. Normalize braces to ensure consistency (X_1 -> X_{1})
+    s = _normalize_to_braces(s)
+    
+    def _parse_linear_expr(expr: str) -> csr_matrix:
+        # Try string_to_vector first (handles linear combinations of joint entropies)
+        try:
+            return string_to_vector(expr, n)
+        except Exception:
+            pass
+
+        # Handle single term with potential coefficient for polym_ineq_to_vector
+        # Pattern: optional sign and coefficient, followed by a term starting with H( or I(
+        m = re.match(r'^([+-]?\d*\.?\d*)([HI]\(.*\))$', expr)
+        if m:
+            coeff_str, term_expr = m.groups()
+            coeff = 1.0
+            if coeff_str == "-":
+                coeff = -1.0
+            elif coeff_str and coeff_str != "+":
+                try:
+                    coeff = float(coeff_str)
+                except ValueError:
+                    coeff = 1.0
+            try:
+                # polym_ineq_to_vector handles H(A|B), I(A;B), I(A;B|C)
+                return coeff * polym_ineq_to_vector(term_expr, n)
+            except Exception:
+                pass
+
+        # Final fallback: try polym_ineq_to_vector on the whole thing
+        return polym_ineq_to_vector(expr, n)
+
+    # 3. Handle leading scalar times parenthesized expression, e.g. 2*(...), -3(...)
+    m = re.match(r'^([+-]?\d*\.?\d*)\((.*)\)$', s)
+    if m:
+        coeff_str, inner_expr = m.groups()
+        coeff = 1.0
+        if coeff_str == "-":
+            coeff = -1.0
+        elif coeff_str and coeff_str != "+":
+            try:
+                coeff = float(coeff_str)
+            except ValueError:
+                coeff = 1.0
+        inner_vec = _parse_linear_expr(inner_expr)
+        return coeff * inner_vec
+
+    # 4. Normal linear expression path
+    return _parse_linear_expr(s)
+
+
+def _extract_var_indices(expr: str) -> List[int]:
+    """
+    Extract all variable indices appearing as X_{...} or X_... in an expression.
+    """
+    idxs: List[int] = []
+    if not expr:
+        return idxs
+    # X_{1,2,3}
+    for inside in re.findall(r"X_\{([^}]+)\}", expr):
+        parts = [p.strip() for p in inside.split(",") if p.strip()]
+        for p in parts:
+            if p.isdigit():
+                idxs.append(int(p))
+    # X_1 (avoid double counting those already in braces; ok if duplicates)
+    for m in re.findall(r"X_(\d+)\b", expr):
+        try:
+            idxs.append(int(m))
+        except Exception:
+            pass
+    return idxs
+
+
+def _strip_comparator(s: str) -> str:
+    # Keep only LHS if input contains "...>=0", "...>0", "...<=0", or "...=0"
+    s = s.strip()
+    for token in (">=0", ">0", "<=0", "=0"):
+        if token in s:
+            s = s.split(token, 1)[0]
+    # Also handle spaced variants like ">= 0"
+    s = re.sub(r'(>=|>|<=|=)\s*0\s*$', '', s).strip()
+    return s
+
+
+def _build_llm_prompt(
+    *,
+    n: int,
+    min_idx: int,
+    max_idx: int,
+    target_inequality_normalized: str,
+    cond_lines: List[str],
+    m_exprs: List[str],
+    idx_to_letter: Optional[Dict[int, str]] = None,
+) -> str:
+    """
+    Build prompt matching the prepared DPO training data format.
+    """
+    # 1. Format Target (ensure comparator)
+    target = target_inequality_normalized.strip()
+    if not any(op in target for op in [">=0", ">0", "<=0", "=0"]):
+        target += ">=0"
+    if _use_alpha_prompt():
+        target = _convert_old_to_alpha(target, idx_to_letter)
+
+    # 2. Format Conditions (use NONE when empty)
+    valid_conds = []
+    for c in (cond_lines or []):
+        c = c.strip()
+        if not c:
+            continue
+        if c in {"(none)", "NONE", "NONE=0"}:
+            continue
+        valid_conds.append(_convert_old_to_alpha(c, idx_to_letter) if _use_alpha_prompt() else c)
+
+    cond_str = "NONE" if not valid_conds else "\n".join(valid_conds)
+
+    # 3. Assemble prompt in DPO 'input' format
+    prompt = f"TARGET:\n{target}\n\n"
+    prompt += f"CONDITIONS:\n{cond_str}\n\n"
+
+    return prompt
+
+
+def _gpu_worker_init(adapter_path: Optional[str], use_dummy: bool, gpu_id: int, max_vars_for_lp: int = 0, Gamma: Optional[List[csr_matrix]] = None):
+    """
+    One worker process binds to one GPU and loads the model once.
+    """
+    # Must be set before importing torch/transformers for correct device visibility.
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+    global _GPU_ADAPTER_PATH, _GPU_USE_DUMMY, _GPU_READY, _CACHED_GAMMA
+    _GPU_ADAPTER_PATH = os.path.abspath(adapter_path) if adapter_path else None
+    _GPU_USE_DUMMY = bool(use_dummy)
+
+    if not _GPU_USE_DUMMY:
+        # Warm model load once per worker process.
+        try:
+            from llm_api_compat import _load_local_model
+        except ModuleNotFoundError:
+            from beam_search_model2.llm_api_compat import _load_local_model
+        # adapter_path may be None to use the baseline model (no PEFT adapter).
+        _load_local_model(adapter_path=_GPU_ADAPTER_PATH, device_map="auto")
+
+    if max_vars_for_lp > 0:
+        if Gamma is not None:
+            # Use the Gamma matrix passed from the main process
+            _CACHED_GAMMA[max_vars_for_lp] = Gamma
+            sys.stderr.write(f"[beam_debug] GPU worker {gpu_id} using Gamma matrix passed from main process (max_vars_for_lp={max_vars_for_lp}).\n")
+            sys.stderr.flush()
+        else:
+            # Pre-generate Shannon inequalities once per worker
+            sys.stderr.write(f"[beam_debug] GPU worker {gpu_id} pre-generating Shannon generators for max_vars_for_lp={max_vars_for_lp}...\n")
+            sys.stderr.flush()
+            gamma_list = _generate_elemental_generators(max_vars_for_lp)
+            shape_str = f" Shape: {gamma_list[0].shape}" if gamma_list else ""
+            sys.stderr.write(f"[beam_debug] GPU worker {gpu_id} done pre-generating Shannon generators.{shape_str}\n")
+            sys.stderr.flush()
+
+    _GPU_READY = True
+
+
+def _expand_node_payload(payload: Dict) -> Dict:
+    """
+    Worker-side expansion: starting from residual_vec, propose k inequalities and subtract them.
+    Returns a dict with a list of potential child states.
+    Note: All heavy modules (numpy, scipy, llm_api_interface) are imported at the top level
+    of this file and will be already available in the worker process's memory.
+    """
+    n = int(payload["n"])
+    min_idx = int(payload["min_idx"])
+    max_idx = int(payload["max_idx"])
+    run_id = payload.get("run_id")
+    cond_lines = payload["cond_lines"]
+    base_path_exprs = list(payload.get("path_exprs") or [])
+    base_residual_vec = payload.get("residual_vec", None)
+    k_steps = max(0, int(payload.get("k_per_call", 1)))
+    llm_mode = (payload.get("llm_mode") or "sequential").strip().lower()
+    max_tries_per_step = int(payload.get("max_tries_per_step", 3))
+
+    adapter_path = payload.get("adapter_path", None)
+    use_dummy = bool(payload.get("use_dummy", False))
+    Gamma = payload.get("Gamma", None)
+    max_vars_for_lp = int(payload.get("max_vars_for_lp", 0))
+    idx_to_letter = payload.get("idx_to_letter", None)
+    letter_to_idx = payload.get("letter_to_idx", None)
+    
+    if Gamma is None and max_vars_for_lp > 0:
+        # Use worker-local cached Gamma (already initialized in _gpu_worker_init)
+        Gamma = _CACHED_GAMMA.get(max_vars_for_lp, None)
+    
+    debug = os.environ.get("BEAM_DEBUG", "0") == "1"
+
+    log_wrong_pruned = bool(payload.get("log_wrong_pruned", False))
+    wrong_data = [] # List of [input_str, output_str]
+
+    # Parse conditions into matrices for row-space and LP checks
+    # Worker-local cache (_COND_CACHE) ensures we don't re-parse for every node.
+    cond_eq_matrix, cond_ge_matrix = _get_cond_matrix_for_run(run_id, n, cond_lines)
+    # if cond_lines and cond_lines != ["NONE"]:
+    #     try:
+    #         eq_vecs = []
+    #         ge_vecs = []
+    #         for cl in cond_lines:
+    #             try:
+    #                 # Note: cand might already have >=0 or =0 from tree_search's cond_lines
+    #                 # but parse_cand_to_vector calls _strip_comparator internally.
+    #                 v = parse_cand_to_vector(cl, n)
+    #                 if v.nnz == 0: continue
+    #                 if ">=0" in cl:
+    #                     ge_vecs.append(v)
+    #                 elif "=0" in cl:
+    #                     eq_vecs.append(v)
+    #                 else:
+    #                     # Fallback if no comparator found in string (shouldn't happen with latest logic)
+    #                     eq_vecs.append(v)
+    #             except: continue
+    #         if eq_vecs:
+    #             cond_eq_matrix = vstack(eq_vecs)
+    #         if ge_vecs:
+    #             cond_ge_matrix = vstack(ge_vecs)
+    #     except:
+    #         pass
+
+    # Check status: 1=proved, -1=impossible, 0=unknown
+    status = _check_shannon_status(base_residual_vec, n, Gamma, cond_eq_matrix, cond_ge_matrix, max_vars_for_lp, debug=debug)
+    if debug:
+        sys.stderr.write(f"[beam_debug] worker_root_status: {status}\n")
+        sys.stderr.flush()
+
+    if status == 1:
+        return {
+            "ok": True,
+            "results": [{
+                "proved": True,
+                "path_exprs": base_path_exprs,
+                "residual_vec": base_residual_vec,
+                "new_ineq": None
+            }],
+            "parse_fail": 0,
+            "out_of_range": 0,
+        }
+    # User requested: No pruning at root node. Let search proceed even if status is -1.
+    
+    results = []
+    pruned_results = []
+    parse_fail = 0
+    out_of_range = 0
+    llm_usage = _empty_llm_usage()
+
+    if llm_mode == "sequential":
+        # Sequential: Subtract k things one after another. Return ONE branch.
+        current_residual_vec = base_residual_vec
+        current_path_exprs = list(base_path_exprs)
+        subtracted_any = False
+        
+        for _step in range(k_steps):
+            got_one = False
+            current_target_norm = vector_to_string(current_residual_vec)
+            
+            for _try in range(max_tries_per_step):
+                prompt = _build_llm_prompt(
+                    n=n, min_idx=min_idx, max_idx=max_idx,
+                    target_inequality_normalized=current_target_norm,
+                    cond_lines=cond_lines, m_exprs=current_path_exprs,
+                    idx_to_letter=idx_to_letter,
+                )
+                cand_list = LLM_propose_inequalities(
+                    prompt=prompt, k=1, adapter_path=adapter_path, use_dummy=use_dummy,
+                )
+                _merge_llm_usage(llm_usage, get_last_llm_stats(reset=True))
+                cand_raw = cand_list[0] if cand_list else ""
+                cand_text = _normalize_candidate_text(cand_raw) if _normalize_candidates_enabled() else cand_raw
+                cand = _normalize_constraint_comparator(_convert_alpha_to_old(cand_text, letter_to_idx))
+                format_reason = _strict_step_format_reason(cand, n=n, cond_lines=cond_lines)
+                if not cand or cand == "wrong" or _is_invalid_negative_ineq(cand, n=n, cond_lines=cond_lines) or format_reason is not None:
+                    if log_wrong_pruned and cand_raw:
+                        wrong_data.append([prompt, cand_raw])
+                    if debug and cand_raw:
+                        sys.stderr.write(
+                            f"[beam_debug] invalid_or_wrong_cand: reason={format_reason or 'wrong_or_negative'} step={cand_raw}\n"
+                        )
+                        sys.stderr.flush()
+                    if format_reason is not None:
+                        llm_usage["format_fail_total"] += 1
+                    pruned_results.append({"is_pruned": True, "reason": "invalid_or_wrong_cand", "path_exprs": current_path_exprs + [cand]})
+                    continue
+                
+                cand_indices = _extract_var_indices(cand)
+                if cand_indices and (min(cand_indices) < min_idx or max(cand_indices) > max_idx):
+                    if log_wrong_pruned:
+                        wrong_data.append([prompt, cand_raw])
+                    out_of_range += 1
+                    pruned_results.append({"is_pruned": True, "reason": "out_of_range", "path_exprs": current_path_exprs + [cand]})
+                    continue
+                try:
+                    vec = parse_cand_to_vector(cand, n)
+                except (ValueError, Exception):
+                    if log_wrong_pruned:
+                        wrong_data.append([prompt, cand_raw])
+                    parse_fail += 1
+                    pruned_results.append({"is_pruned": True, "reason": "parse_fail", "path_exprs": current_path_exprs + [cand]})
+                    continue
+
+                # Validation for Bayesian equalities
+                if re.search(r'(?<![<>])=\s*0', cand):
+                    if not _is_in_row_space(vec, cond_eq_matrix):
+                        if log_wrong_pruned:
+                            wrong_data.append([prompt, cand_raw])
+                        if debug:
+                            sys.stderr.write(f"[beam_debug] hallucinated_equality: step={cand_raw} not in row-space of conditions\n")
+                            sys.stderr.flush()
+                        pruned_results.append({"is_pruned": True, "reason": "hallucinated_equality", "path_exprs": current_path_exprs + [cand]})
+                        continue # Hallucinated equality
+                    else:
+                        if debug:
+                            sys.stderr.write(f"[beam_debug] equality_verified: step={cand_raw} is in row-space\n")
+                            sys.stderr.flush()
+                
+                new_residual = current_residual_vec - vec
+                # Check status: 1=proved, -1=impossible (false)
+                status = _check_shannon_status(new_residual, n, Gamma, cond_eq_matrix, cond_ge_matrix, max_vars_for_lp, debug=debug)
+                
+                # Check if obviously negative (simple check)
+                if _is_obviously_negative(new_residual):
+                    if log_wrong_pruned:
+                        wrong_data.append([prompt, cand_raw])
+                    if debug:
+                        res_str = vector_to_string(new_residual)
+                        sys.stderr.write(f"[beam_debug] obviously_negative_prune: residual={res_str}\n")
+                        sys.stderr.flush()
+                    pruned_results.append({"is_pruned": True, "reason": "obviously_negative", "residual_vec": new_residual, "path_exprs": current_path_exprs + [cand]})
+                    got_one = False # Don't continue this branch
+                    break
+                
+                # Prune if impossible via LP
+                if status == -1:
+                    if log_wrong_pruned:
+                        wrong_data.append([prompt, cand_raw])
+                    if debug:
+                        res_str = vector_to_string(new_residual)
+                        sys.stderr.write(f"[beam_debug] lp_false_prune: residual={res_str}\n")
+                        sys.stderr.flush()
+                    pruned_results.append({"is_pruned": True, "reason": "lp_false", "residual_vec": new_residual, "path_exprs": current_path_exprs + [cand]})
+                    got_one = False
+                    break
+                
+                current_path_exprs.append(cand)
+                current_residual_vec = new_residual
+                subtracted_any = True
+                got_one = True
+
+                if status == 1:
+                    break
+                break
+            if not got_one: break
+            if _is_positive_polymatroid(current_residual_vec, n, Gamma, cond_eq_matrix, cond_ge_matrix, max_vars_for_lp): break
+            
+        if subtracted_any:
+            results.append({
+                "proved": _is_positive_polymatroid(current_residual_vec, n, Gamma, cond_eq_matrix, cond_ge_matrix, max_vars_for_lp),
+                "path_exprs": current_path_exprs,
+                "residual_vec": current_residual_vec,
+                "new_ineq": current_path_exprs[len(base_path_exprs):]
+            })
+    else:
+        # Batch: Ask for k things. Each becomes a SEPARATE branch (subtracting only one).
+        current_target_norm = vector_to_string(base_residual_vec)
+        
+        tries = 0
+        while len(results) < k_steps and tries < max_tries_per_step:
+            tries += 1
+            prompt = _build_llm_prompt(
+                n=n, min_idx=min_idx, max_idx=max_idx,
+                target_inequality_normalized=current_target_norm,
+                cond_lines=cond_lines, m_exprs=base_path_exprs,
+                idx_to_letter=idx_to_letter,
+            )
+            cand_list = LLM_propose_inequalities(
+                prompt=prompt, k=k_steps, adapter_path=adapter_path, use_dummy=use_dummy,
+                num_return_sequences=k_steps,
+            )
+            _merge_llm_usage(llm_usage, get_last_llm_stats(reset=True))
+            for cand in cand_list:
+                if len(results) >= k_steps: break
+                cand_raw = cand
+                cand_text = _normalize_candidate_text(cand_raw) if _normalize_candidates_enabled() else cand_raw
+                cand = _normalize_constraint_comparator(_convert_alpha_to_old(cand_text, letter_to_idx))
+                format_reason = _strict_step_format_reason(cand, n=n, cond_lines=cond_lines)
+                if not cand or cand == "wrong" or _is_invalid_negative_ineq(cand, n=n, cond_lines=cond_lines) or format_reason is not None:
+                    if log_wrong_pruned and cand_raw:
+                        wrong_data.append([prompt, cand_raw])
+                    if debug and cand_raw:
+                        sys.stderr.write(
+                            f"[beam_debug] invalid_or_wrong_cand: reason={format_reason or 'wrong_or_negative'} step={cand_raw}\n"
+                        )
+                        sys.stderr.flush()
+                    if format_reason is not None:
+                        llm_usage["format_fail_total"] += 1
+                    pruned_results.append({"is_pruned": True, "reason": "invalid_or_wrong_cand", "path_exprs": base_path_exprs + [cand]})
+                    continue
+                
+                cand_indices = _extract_var_indices(cand)
+                if cand_indices and (min(cand_indices) < min_idx or max(cand_indices) > max_idx):
+                    if log_wrong_pruned:
+                        wrong_data.append([prompt, cand_raw])
+                    out_of_range += 1
+                    pruned_results.append({"is_pruned": True, "reason": "out_of_range", "path_exprs": base_path_exprs + [cand]})
+                    continue
+                try:
+                    vec = parse_cand_to_vector(cand, n)
+                except (ValueError, Exception):
+                    if log_wrong_pruned:
+                        wrong_data.append([prompt, cand_raw])
+                    parse_fail += 1
+                    pruned_results.append({"is_pruned": True, "reason": "parse_fail", "path_exprs": base_path_exprs + [cand]})
+                    continue
+                
+                # Validation for Bayesian equalities
+                if re.search(r'(?<![<>])=\s*0', cand):
+                    if not _is_in_row_space(vec, cond_eq_matrix):
+                        if log_wrong_pruned:
+                            wrong_data.append([prompt, cand_raw])
+                        if debug:
+                            sys.stderr.write(f"[beam_debug] hallucinated_equality: step={cand_raw} not in row-space of conditions\n")
+                            sys.stderr.flush()
+                        pruned_results.append({"is_pruned": True, "reason": "hallucinated_equality", "path_exprs": base_path_exprs + [cand]})
+                        continue # Hallucinated equality
+                    else:
+                        if debug:
+                            sys.stderr.write(f"[beam_debug] equality_verified: step={cand_raw} is in row-space\n")
+                            sys.stderr.flush()
+
+                new_residual = base_residual_vec - vec
+                # Check status: 1=proved, -1=impossible (false)
+                status = _check_shannon_status(new_residual, n, Gamma, cond_eq_matrix, cond_ge_matrix, max_vars_for_lp, debug=debug)
+                is_proved = (status == 1)
+                
+                if not is_proved:
+                    # 1. Simple obviously negative check
+                    if _is_obviously_negative(new_residual):
+                        if log_wrong_pruned:
+                            wrong_data.append([prompt, cand_raw])
+                        if debug:
+                            res_str = vector_to_string(new_residual)
+                            sys.stderr.write(f"[beam_debug] obviously_negative_prune: residual={res_str}\n")
+                            sys.stderr.flush()
+                        pruned_results.append({"is_pruned": True, "reason": "obviously_negative", "residual_vec": new_residual, "path_exprs": base_path_exprs + [cand]})
+                        continue # Prune this candidate
+                    
+                    # 2. LP impossible check
+                    if status == -1:
+                        if log_wrong_pruned:
+                            wrong_data.append([prompt, cand_raw])
+                        if debug:
+                            res_str = vector_to_string(new_residual)
+                            sys.stderr.write(f"[beam_debug] lp_false_prune: residual={res_str}\n")
+                            sys.stderr.flush()
+                        pruned_results.append({"is_pruned": True, "reason": "lp_false", "residual_vec": new_residual, "path_exprs": base_path_exprs + [cand]})
+                        continue # Prune this candidate
+
+                results.append({
+                    "proved": is_proved,
+                    "path_exprs": base_path_exprs + [cand],
+                    "residual_vec": new_residual,
+                    "new_ineq": [cand]
+                })
+
+    return {
+        "ok": len(results) > 0,
+        "results": results,
+        "pruned_results": pruned_results,
+        "parse_fail": parse_fail,
+        "out_of_range": out_of_range,
+        "wrong_data": wrong_data,
+        "llm_usage": llm_usage,
+    }
+
+# Define Node class
+
+class Node:
+    def __init__(
+        self,
+        residual_vec: Optional[csr_matrix] = None,
+        path_exprs: Optional[List[str]] = None,
+        proved: bool = False,
+        children=None,
+        parent=None,
+        score: float = 0.0,
+        is_pruned: bool = False,
+    ):
+        if children is None:
+            children = []
+        if path_exprs is None:
+            path_exprs = []
+
+        self.residual_vec = residual_vec
+        self.path_exprs = list(path_exprs)
+        self.proved = proved
+        self.children = children
+        self.parent = parent
+        self.score = score
+        self.is_pruned = is_pruned
+
+def relabel_f_and_conditions(
+    f_str: str,
+    cond_list: List[str],
+) -> Tuple[str, List[str], Dict[int, int], int]:
+    """
+    对 f_target 和多条 conditions 一起做变量重编号。
+    要求输入里变量形式都是 X_{...}，例如:
+        H(X_{1,3}) + H(X_{1,23}) >= 0
+        H(X_{1,2}) >= 0
+        H(X_{3}) = 0  (X_{3} 也可以)
+
+    步骤：
+      1. 从 f_str + cond_list 里找出所有出现的 index（1,3,23,...）
+      2. 按升序排序，映射到 1..n
+      3. 把所有 X_{...} 中的旧 index 换成新 index
+
+    返回：
+      f_new: 重编号后的 f 字符串
+      conds_new: 重编号后的 condition 字符串列表
+      mapping: {旧 index : 新 index}
+      n: 变量个数（新编号的最大值）
+    """
+
+    # 1) 收集所有出现的旧变量下标
+    all_exprs = [f_str] + list(cond_list)
+    old_indices = set()
+    
+    # Normalize expressions to brace format first (H(X_1,X_2) -> H(X_{1,2}))
+    def normalize_to_braces(s):
+        """Convert H(X_1,X_2) to H(X_{1,2}) format"""
+        def repl_no_braces(match):
+            prefix = match.group(1) or ''  # Coefficient like "-35*"
+            content = match.group(2)       # X_1,X_2 or X_1
+            if content.startswith('{') and content.endswith('}'):
+                return match.group(0)  # Already normalized
+            if ',' in content:
+                vars_list = [v.strip().replace('X_', '') for v in content.split(',')]
+                normalized = ','.join(vars_list)
+                return f"{prefix}H(X_{{{normalized}}})"
+            else:
+                var = content.replace('X_', '')
+                return f"{prefix}H(X_{{{var}}})"
+        return re.sub(r'([+-]?\d*\.?\d*\*?)H\(X_([^)]+)\)', repl_no_braces, s)
+    
+    # Normalize all expressions first
+    all_exprs_normalized = [normalize_to_braces(s) for s in all_exprs]
+
+    for s in all_exprs_normalized:
+        # 匹配 X_{...}，拿里面的 "1,3" 之类 (after normalization, all are in brace format)
+        for inside in re.findall(r'X_\{([^}]+)\}', s):
+            parts = [p.strip() for p in inside.split(',') if p.strip()]
+            for p in parts:
+                old_indices.add(int(p))
+
+    if not old_indices:
+        # 没有变量，直接返回原表达式
+        mapping: Dict[int, int] = {}
+        return f_str, cond_list, mapping, 0
+
+    # 2) 排序后映射到 1..n
+    sorted_old = sorted(old_indices)       # 例如 [1,3,23]
+    mapping: Dict[int, int] = {
+        old: new for new, old in enumerate(sorted_old, start=1)
+    }
+    n = len(sorted_old)
+
+    # 3) 用 mapping 替换表达式中的 index
+    def repl(match: re.Match) -> str:
+        inside = match.group(1)           # 原来的 "1,3" 或 "23"
+        parts = [p.strip() for p in inside.split(',') if p.strip()]
+        new_parts = [str(mapping[int(p)]) for p in parts]
+        return f"X_{{{','.join(new_parts)}}}"
+
+    all_exprs_relabel = [
+        re.sub(r'X_\{([^}]+)\}', repl, s)
+        for s in all_exprs_normalized
+    ]
+
+    f_new = all_exprs_relabel[0]
+    conds_new = all_exprs_relabel[1:]
+
+    return f_new, conds_new, mapping, n
+
+# Define the algorithm
+def tree_search(root_node, max_depth, rollout_count, target_inequality, conditions, n, 
+                Gamma: Optional[List[csr_matrix]] = None,
+                adapter_path: Optional[str] = None,
+                use_dummy: bool = False,
+                k_per_call: int = 1,
+                llm_mode: str = "sequential",
+                lp_workers: int = 0,
+                gpu_devices: Optional[List[int]] = None,
+                gpu_executors: Optional[List[ProcessPoolExecutor]] = None,
+                beam_size: int = 0,
+                random_prune: bool = False,
+                prune_seed: Optional[int] = None,
+                max_vars_for_lp: int = 0,
+                log_wrong_pruned: bool = False,
+                wrong_pruned_path: Optional[str] = None,
+                sample_time_budget_sec: float = 0.0,
+                sample_tree_budget: int = 0,
+                sample_llm_calls_budget: int = 0,
+                sample_llm_fail_budget: int = 0,
+                depth1_rollouts: Optional[int] = None):
+    """
+    Algorithm for Data Generation via LLM-Guided Tree Search (Model 2: Subtraction based).
+    """
+    _seed_indices = _extract_var_indices(target_inequality)
+    for _c in (conditions or []):
+        _seed_indices.extend(_extract_var_indices(_c))
+    if _seed_indices:
+        min_idx = min(_seed_indices)
+        max_idx = max(_seed_indices)
+    else:
+        min_idx, max_idx = 1, int(n)
+
+    min_idx = max(1, int(min_idx))
+    max_idx = min(int(n), int(max_idx))
+    if min_idx > max_idx:
+        min_idx, max_idx = 1, int(n)
+
+    debug = os.environ.get("BEAM_DEBUG", "0") == "1"
+    prune_rng = None
+    if beam_size and beam_size > 0 and random_prune:
+        prune_rng = random.Random(prune_seed)
+
+    target_inequality = _normalize_to_braces(target_inequality)
+    conditions = [
+        _normalize_constraint_comparator(_normalize_to_braces(c), add_default=True)
+        for c in (conditions or [])
+    ]
+    idx_to_letter, letter_to_idx = _build_alpha_mapping([target_inequality] + list(conditions or []))
+
+    if Gamma is None and max_vars_for_lp > 0:
+        Gamma = _generate_elemental_generators(max_vars_for_lp)
+
+    f_csr = parse_cand_to_vector(target_inequality, n)
+    cond_eq_csr, cond_ge_csr = _parse_condition_matrices(conditions, n)
+
+    root_node.residual_vec = f_csr
+    root_node.path_exprs = []
+
+    seen_residuals = set()
+    root_key = vector_to_string(root_node.residual_vec)
+    seen_residuals.add(root_key)
+
+    nodes = [root_node]
+    tree = [root_node]
+    lp_calls = 0
+    parse_fail = 0
+    out_of_range = 0
+    all_wrong_data = []
+    llm_usage = _empty_llm_usage()
+    sample_time_budget_sec = float(sample_time_budget_sec or 0.0)
+    sample_tree_budget = int(sample_tree_budget or 0)
+    sample_llm_calls_budget = int(sample_llm_calls_budget or 0)
+    sample_llm_fail_budget = int(sample_llm_fail_budget or 0)
+    depth1_rollouts = int(depth1_rollouts) if depth1_rollouts and int(depth1_rollouts) > 0 else None
+    stop_reason = None
+    t_start = time.monotonic()
+
+    llm_mode = (llm_mode or "sequential").strip().lower()
+    run_id = uuid.uuid4().hex
+    global _CACHED_GPU_EXECUTORS, _CACHED_GPU_PARAMS
+    gpu_devices = list(gpu_devices) if gpu_devices else []
+
+    def _flush_wrong_data() -> None:
+        if log_wrong_pruned and wrong_pruned_path and all_wrong_data:
+            try:
+                with open(wrong_pruned_path, "a", encoding="utf-8") as f:
+                    for inp_str, out_str in all_wrong_data:
+                        f.write(json.dumps({"input": inp_str, "output": out_str}, ensure_ascii=False) + "\n")
+                all_wrong_data.clear()
+            except Exception as e:
+                if debug:
+                    sys.stderr.write(f"[beam_debug] error_writing_wrong_data: {e}\n")
+                    sys.stderr.flush()
+
+    def _budget_exceeded() -> Optional[str]:
+        if sample_time_budget_sec > 0 and (time.monotonic() - t_start) > sample_time_budget_sec:
+            return "time_budget"
+        if sample_tree_budget > 0 and len(tree) >= sample_tree_budget:
+            return "tree_budget"
+        if sample_llm_calls_budget > 0 and llm_usage.get("llm_calls", 0) >= sample_llm_calls_budget:
+            return "llm_calls_budget"
+        if sample_llm_fail_budget > 0 and llm_usage.get("format_fail_total", 0) >= sample_llm_fail_budget:
+            return "llm_fail_budget"
+        return None
+
+    def _refresh_stop_reason() -> Optional[str]:
+        nonlocal stop_reason
+        if stop_reason is None:
+            stop_reason = _budget_exceeded()
+        return stop_reason
+
+    def _finalize(proved: bool, x, expr_str):
+        _flush_wrong_data()
+        return proved, tree, x, expr_str, llm_usage, stop_reason
+
+    current_params = (adapter_path, use_dummy, tuple(gpu_devices), max_vars_for_lp)
+
+    if gpu_executors is not None:
+        pass
+    elif _CACHED_GPU_EXECUTORS is not None and _CACHED_GPU_PARAMS == current_params:
+        gpu_executors = _CACHED_GPU_EXECUTORS
+    elif gpu_devices:
+        if _CACHED_GPU_EXECUTORS is not None:
+            for ex in _CACHED_GPU_EXECUTORS:
+                try:
+                    ex.shutdown(wait=True, cancel_futures=True)
+                except Exception:
+                    pass
+
+        gpu_executors = []
+        try:
+            gpu_ctx = mp.get_context("spawn")
+        except Exception:
+            gpu_ctx = None
+        for gid in gpu_devices:
+            gpu_executors.append(
+                ProcessPoolExecutor(
+                    max_workers=1,
+                    mp_context=gpu_ctx,
+                    initializer=_gpu_worker_init,
+                    initargs=(adapter_path, use_dummy, int(gid), int(max_vars_for_lp), Gamma),
+                )
+            )
+        _CACHED_GPU_EXECUTORS = gpu_executors
+        _CACHED_GPU_PARAMS = current_params
+
+    if _is_positive_polymatroid(root_node.residual_vec, n, Gamma, cond_eq_csr, cond_ge_csr, max_vars_for_lp, debug=debug):
+        if debug:
+            sys.stderr.write(f"[beam_debug] proved_at_root: Target={target_inequality}\n")
+            sys.stderr.flush()
+        return _finalize(True, None, root_node.path_exprs)
+
+    try:
+        cond_raw = conditions if conditions else []
+        cond_lines = []
+        for c in cond_raw:
+            c_norm = _normalize_constraint_comparator(_normalize_to_braces(c.strip()), add_default=True)
+            cond_lines.append(c_norm)
+
+        if not cond_lines:
+            cond_lines = ["NONE=0"]
+
+        for depth in range(1, max_depth + 1):
+            if _refresh_stop_reason():
+                break
+            next_level_nodes = []
+            depth_rollouts = depth1_rollouts if depth == 1 and depth1_rollouts is not None else (32 if depth == 1 else rollout_count)
+
+            if gpu_executors:
+                futures = []
+                fut_meta = {}
+                rr = 0
+                max_tries_per_step = int(os.environ.get("BEAM_MAX_TRIES_PER_STEP", "3"))
+
+                for node in nodes:
+                    if _refresh_stop_reason():
+                        break
+                    for i in range(depth_rollouts):
+                        if _refresh_stop_reason():
+                            break
+                        payload = {
+                            "n": int(n),
+                            "min_idx": int(min_idx),
+                            "max_idx": int(max_idx),
+                            "run_id": run_id,
+                            "cond_lines": cond_lines,
+                            "path_exprs": list(node.path_exprs),
+                            "residual_vec": node.residual_vec,
+                            "k_per_call": int(k_per_call),
+                            "llm_mode": llm_mode,
+                            "max_tries_per_step": max_tries_per_step,
+                            "adapter_path": adapter_path,
+                            "use_dummy": bool(use_dummy),
+                            "Gamma": None,
+                            "max_vars_for_lp": int(max_vars_for_lp),
+                            "log_wrong_pruned": log_wrong_pruned,
+                            "idx_to_letter": idx_to_letter,
+                            "letter_to_idx": letter_to_idx,
+                        }
+                        ex = gpu_executors[rr % len(gpu_executors)]
+                        rr += 1
+                        fut = ex.submit(_expand_node_payload, payload)
+                        futures.append(fut)
+                        fut_meta[fut] = (node, i)
+                    if stop_reason:
+                        break
+
+                if not stop_reason:
+                    for fut in as_completed(futures):
+                        if stop_reason:
+                            break
+                        node, rollout_idx = fut_meta[fut]
+                        try:
+                            r = fut.result()
+                        except Exception as e:
+                            if _is_fatal_gpu_worker_exception(e):
+                                raise
+                            if debug:
+                                sys.stderr.write(f"[beam_debug] gpu_worker_error: {type(e).__name__}: {e}\n")
+                                sys.stderr.flush()
+                            continue
+                        parse_fail += int(r.get("parse_fail", 0))
+                        out_of_range += int(r.get("out_of_range", 0))
+                        worker_llm_usage = r.get("llm_usage")
+                        if worker_llm_usage:
+                            for key in llm_usage:
+                                llm_usage[key] += int(worker_llm_usage.get(key, 0))
+                        if log_wrong_pruned and "wrong_data" in r:
+                            all_wrong_data.extend(r["wrong_data"])
+                        if _refresh_stop_reason():
+                            break
+
+                        for pr_data in r.get("pruned_results", []):
+                            pr_node = Node(
+                                proved=False,
+                                parent=node,
+                                path_exprs=list(pr_data.get("path_exprs") or []),
+                                residual_vec=pr_data.get("residual_vec"),
+                                is_pruned=True,
+                            )
+                            tree.append(pr_node)
+                            if _refresh_stop_reason():
+                                break
+                        if stop_reason:
+                            break
+
+                        if not r.get("ok", False):
+                            continue
+
+                        for res_data in r.get("results", []):
+                            if _refresh_stop_reason():
+                                break
+                            res_vec = res_data.get("residual_vec", None)
+                            if res_vec is None:
+                                continue
+
+                            res_key = vector_to_string(res_vec)
+                            if res_key in seen_residuals:
+                                if debug:
+                                    sys.stderr.write(f"[beam_debug] duplicate_prune: depth={depth} rollout={rollout_idx} Residual={res_key[:50]}...\n")
+                                    sys.stderr.flush()
+                                pr_node = Node(
+                                    proved=False,
+                                    parent=node,
+                                    path_exprs=list(res_data.get("path_exprs") or []),
+                                    residual_vec=res_vec,
+                                    is_pruned=True,
+                                )
+                                tree.append(pr_node)
+                                if _refresh_stop_reason():
+                                    break
+                                continue
+                            seen_residuals.add(res_key)
+
+                            child = Node(
+                                proved=res_data.get("proved", False),
+                                parent=node,
+                                path_exprs=list(res_data.get("path_exprs") or []),
+                                residual_vec=res_vec,
+                            )
+
+                            if debug:
+                                _beam_debug_print_M(
+                                    depth=depth,
+                                    rollout=rollout_idx,
+                                    path_exprs=child.path_exprs,
+                                    residual_vec=child.residual_vec,
+                                    action="expand_done",
+                                )
+
+                            if child.proved:
+                                if debug:
+                                    sys.stderr.write(f"[beam_debug] proved: path={child.path_exprs}\n")
+                                    sys.stderr.flush()
+                                tree.append(child)
+                                return _finalize(True, None, child.path_exprs)
+
+                            next_level_nodes.append(child)
+                        if stop_reason:
+                            break
+
+                if stop_reason:
+                    for fut in futures:
+                        try:
+                            fut.cancel()
+                        except Exception:
+                            pass
+            else:
+                for node in nodes:
+                    if _refresh_stop_reason():
+                        break
+                    for i in range(depth_rollouts):
+                        if _refresh_stop_reason():
+                            break
+                        current_residual_vec = node.residual_vec
+                        current_path_exprs = list(node.path_exprs)
+
+                        if llm_mode == "sequential":
+                            subtracted_any = False
+                            for _step in range(k_per_call):
+                                if _refresh_stop_reason():
+                                    break
+                                current_target_norm = vector_to_string(current_residual_vec)
+
+                                prompt = _build_llm_prompt(
+                                    n=n, min_idx=min_idx, max_idx=max_idx,
+                                    target_inequality_normalized=current_target_norm,
+                                    cond_lines=cond_lines, m_exprs=current_path_exprs,
+                                    idx_to_letter=idx_to_letter,
+                                )
+                                cand_list = LLM_propose_inequalities(prompt, k=1, adapter_path=adapter_path, use_dummy=use_dummy)
+                                _merge_llm_usage(llm_usage, get_last_llm_stats(reset=True))
+                                if _refresh_stop_reason():
+                                    break
+                                if not cand_list:
+                                    tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs, is_pruned=True))
+                                    _refresh_stop_reason()
+                                    break
+                                cand_raw = cand_list[0]
+                                cand_text = _normalize_candidate_text(cand_raw) if _normalize_candidates_enabled() else cand_raw
+                                cand = _normalize_constraint_comparator(_convert_alpha_to_old(cand_text, letter_to_idx))
+                                format_reason = _strict_step_format_reason(cand, n=n, cond_lines=cond_lines)
+                                if cand == "wrong" or _is_invalid_negative_ineq(cand, n=n, cond_lines=cond_lines) or format_reason is not None:
+                                    if log_wrong_pruned:
+                                        all_wrong_data.append([prompt, cand_raw])
+                                    if debug:
+                                        sys.stderr.write(
+                                            f"[beam_debug] invalid_or_wrong_cand_manual: reason={format_reason or 'wrong_or_negative'} step={cand_raw}\n"
+                                        )
+                                        sys.stderr.flush()
+                                    if format_reason is not None:
+                                        llm_usage["format_fail_total"] += 1
+                                    tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], is_pruned=True))
+                                    _refresh_stop_reason()
+                                    break
+                                try:
+                                    vec = parse_cand_to_vector(cand, n)
+                                    if re.search(r'(?<![<>])=\s*0', cand):
+                                        if not _is_in_row_space(vec, cond_eq_csr):
+                                            if log_wrong_pruned:
+                                                all_wrong_data.append([prompt, cand_raw])
+                                            if debug:
+                                                sys.stderr.write(f"[beam_debug] hallucinated_equality_manual: step={cand_raw} not in row-space of conditions\n")
+                                                sys.stderr.flush()
+                                            tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], is_pruned=True))
+                                            _refresh_stop_reason()
+                                            break
+                                        else:
+                                            if debug:
+                                                sys.stderr.write(f"[beam_debug] equality_verified_manual: step={cand_raw} is in row-space\n")
+                                                sys.stderr.flush()
+
+                                    new_residual = current_residual_vec - vec
+                                    status = _check_shannon_status(new_residual, n, Gamma, cond_eq_csr, cond_ge_csr, max_vars_for_lp, debug=debug)
+
+                                    if _is_obviously_negative(new_residual):
+                                        if log_wrong_pruned:
+                                            all_wrong_data.append([prompt, cand_raw])
+                                        if debug:
+                                            res_str = vector_to_string(new_residual)
+                                            sys.stderr.write(f"[beam_debug] obviously_negative_prune: residual={res_str}\n")
+                                            sys.stderr.flush()
+                                        tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual, is_pruned=True))
+                                        subtracted_any = False
+                                        _refresh_stop_reason()
+                                        break
+
+                                    if status == -1:
+                                        if log_wrong_pruned:
+                                            all_wrong_data.append([prompt, cand_raw])
+                                        if debug:
+                                            res_str = vector_to_string(new_residual)
+                                            sys.stderr.write(f"[beam_debug] lp_false_prune_manual: residual={res_str}\n")
+                                            sys.stderr.flush()
+                                        tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual, is_pruned=True))
+                                        subtracted_any = False
+                                        _refresh_stop_reason()
+                                        break
+
+                                    if status == 1:
+                                        current_residual_vec = new_residual
+                                        current_path_exprs.append(cand)
+                                        subtracted_any = True
+                                        break
+
+                                    res_key = vector_to_string(new_residual)
+                                    if res_key in seen_residuals:
+                                        if debug:
+                                            sys.stderr.write(f"[beam_debug] duplicate_prune: depth={depth} rollout={i} Residual={res_key[:50]}...\n")
+                                            sys.stderr.flush()
+                                        tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual, is_pruned=True))
+                                        _refresh_stop_reason()
+                                        break
+
+                                    seen_residuals.add(res_key)
+                                    current_residual_vec = new_residual
+                                    current_path_exprs.append(cand)
+                                    subtracted_any = True
+                                except Exception:
+                                    if log_wrong_pruned:
+                                        all_wrong_data.append([prompt, cand_raw])
+                                    tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], is_pruned=True))
+                                    _refresh_stop_reason()
+                                    continue
+
+                            if stop_reason:
+                                break
+                            if subtracted_any:
+                                is_proved = _is_positive_polymatroid(current_residual_vec, n, Gamma, cond_eq_csr, cond_ge_csr, max_vars_for_lp, debug=debug)
+                                child = Node(proved=is_proved, parent=node, path_exprs=current_path_exprs, residual_vec=current_residual_vec)
+                                if debug:
+                                    _beam_debug_print_M(depth=depth, rollout=i, path_exprs=child.path_exprs, residual_vec=child.residual_vec, action="manual_expand")
+                                if is_proved:
+                                    if debug:
+                                        sys.stderr.write(f"[beam_debug] proved: path={current_path_exprs}\n")
+                                        sys.stderr.flush()
+                                    tree.append(child)
+                                    return _finalize(True, None, child.path_exprs)
+                                next_level_nodes.append(child)
+                        else:
+                            current_target_norm = vector_to_string(current_residual_vec)
+
+                            prompt = _build_llm_prompt(
+                                n=n, min_idx=min_idx, max_idx=max_idx,
+                                target_inequality_normalized=current_target_norm,
+                                cond_lines=cond_lines, m_exprs=current_path_exprs,
+                                idx_to_letter=idx_to_letter,
+                            )
+                            cand_list = LLM_propose_inequalities(prompt, k=k_per_call, adapter_path=adapter_path, use_dummy=use_dummy)
+                            _merge_llm_usage(llm_usage, get_last_llm_stats(reset=True))
+                            if _refresh_stop_reason():
+                                break
+                            for cand in cand_list:
+                                if _refresh_stop_reason():
+                                    break
+                                cand_raw = cand
+                                cand_text = _normalize_candidate_text(cand_raw) if _normalize_candidates_enabled() else cand_raw
+                                cand = _normalize_constraint_comparator(_convert_alpha_to_old(cand_text, letter_to_idx))
+                                format_reason = _strict_step_format_reason(cand, n=n, cond_lines=cond_lines)
+                                if not cand or cand == "wrong" or _is_invalid_negative_ineq(cand, n=n, cond_lines=cond_lines) or format_reason is not None:
+                                    if log_wrong_pruned:
+                                        all_wrong_data.append([prompt, cand_raw])
+                                    if debug and cand_raw:
+                                        sys.stderr.write(
+                                            f"[beam_debug] invalid_or_wrong_cand_manual_batch: reason={format_reason or 'wrong_or_negative'} step={cand_raw}\n"
+                                        )
+                                        sys.stderr.flush()
+                                    if format_reason is not None:
+                                        llm_usage["format_fail_total"] += 1
+                                    tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], is_pruned=True))
+                                    _refresh_stop_reason()
+                                    continue
+                                try:
+                                    vec = parse_cand_to_vector(cand, n)
+                                    if re.search(r'(?<![<>])=\s*0', cand):
+                                        if not _is_in_row_space(vec, cond_eq_csr):
+                                            if log_wrong_pruned:
+                                                all_wrong_data.append([prompt, cand_raw])
+                                            if debug:
+                                                sys.stderr.write(f"[beam_debug] hallucinated_equality_manual: step={cand_raw} not in row-space of conditions\n")
+                                                sys.stderr.flush()
+                                            tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], is_pruned=True))
+                                            _refresh_stop_reason()
+                                            continue
+                                        else:
+                                            if debug:
+                                                sys.stderr.write(f"[beam_debug] equality_verified_manual: step={cand_raw} is in row-space\n")
+                                                sys.stderr.flush()
+
+                                    new_residual = current_residual_vec - vec
+                                    status = _check_shannon_status(new_residual, n, Gamma, cond_eq_csr, cond_ge_csr, max_vars_for_lp, debug=debug)
+                                    is_proved = (status == 1)
+
+                                    if not is_proved and _is_obviously_negative(new_residual):
+                                        if log_wrong_pruned:
+                                            all_wrong_data.append([prompt, cand_raw])
+                                        if debug:
+                                            res_str = vector_to_string(new_residual)
+                                            sys.stderr.write(f"[beam_debug] obviously_negative_prune: residual={res_str}\n")
+                                            sys.stderr.flush()
+                                        tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual, is_pruned=True))
+                                        _refresh_stop_reason()
+                                        continue
+
+                                    if not is_proved and status == -1:
+                                        if log_wrong_pruned:
+                                            all_wrong_data.append([prompt, cand_raw])
+                                        if debug:
+                                            res_str = vector_to_string(new_residual)
+                                            sys.stderr.write(f"[beam_debug] lp_false_prune_manual_batch: residual={res_str}\n")
+                                            sys.stderr.flush()
+                                        tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual, is_pruned=True))
+                                        _refresh_stop_reason()
+                                        continue
+
+                                    res_key = vector_to_string(new_residual)
+                                    if res_key in seen_residuals:
+                                        if debug:
+                                            sys.stderr.write(f"[beam_debug] duplicate_prune: depth={depth} rollout={i} Residual={res_key[:50]}...\n")
+                                            sys.stderr.flush()
+                                        tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual, is_pruned=True))
+                                        _refresh_stop_reason()
+                                        continue
+
+                                    seen_residuals.add(res_key)
+                                    child = Node(proved=is_proved, parent=node, path_exprs=current_path_exprs + [cand], residual_vec=new_residual)
+                                    if debug:
+                                        _beam_debug_print_M(depth=depth, rollout=i, path_exprs=child.path_exprs, residual_vec=child.residual_vec, action="manual_expand_batch")
+                                    if is_proved:
+                                        if debug:
+                                            sys.stderr.write(f"[beam_debug] proved: path={current_path_exprs + [cand]}\n")
+                                            sys.stderr.flush()
+                                        tree.append(child)
+                                        return _finalize(True, None, child.path_exprs)
+                                    next_level_nodes.append(child)
+                                except Exception:
+                                    tree.append(Node(proved=False, parent=node, path_exprs=current_path_exprs + [cand], is_pruned=True))
+                                    _refresh_stop_reason()
+                                    continue
+                        if stop_reason:
+                            break
+                    if stop_reason:
+                        break
+
+            if stop_reason:
+                break
+            if not next_level_nodes:
+                if debug:
+                    sys.stderr.write(f"[beam_debug] search_stuck: depth={depth} next_level_nodes is empty\n")
+                    sys.stderr.flush()
+                break
+
+            nodes = next_level_nodes
+
+            if beam_size and len(nodes) > beam_size:
+                before = len(nodes)
+                nodes, pruned_by_beam = _select_beam_nodes(
+                    nodes,
+                    beam_size,
+                    random_prune=random_prune,
+                    rng=prune_rng,
+                )
+                for node in nodes:
+                    node.score = _get_residual_score(node.residual_vec)
+                for pn in pruned_by_beam:
+                    pn.is_pruned = True
+                    tree.append(pn)
+                    if _refresh_stop_reason():
+                        break
+                if stop_reason:
+                    break
+                if debug:
+                    strategy = "seeded_uniform_random" if random_prune else "short_residual_greedy"
+                    sys.stderr.write(
+                        f"[beam_debug] prune: depth={depth} strategy={strategy} beam_size={beam_size} "
+                        f"before={before} after={len(nodes)}\n"
+                    )
+                    sys.stderr.flush()
+            tree.extend(nodes)
+            if _refresh_stop_reason():
+                break
+
+        return _finalize(False, None, None)
+    finally:
+        pass

mce220_runner/beam_search_model2/llm_api_compat.py

@@ -0,0 +1,26 @@
+"""Portable compatibility import for the shared local LLM interface.
+
+The implementation lives in :mod:`grpo_pipeline.modules.llm_api_interface`.
+This module replaces the repository's former absolute Linux symlink so the
+beam-search entry points work from a fresh checkout on any platform.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+
+
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+_shared = importlib.import_module("grpo_pipeline.modules.llm_api_interface")
+__all__ = [name for name in vars(_shared) if not name.startswith("_")]
+globals().update({name: getattr(_shared, name) for name in __all__})
+
+
+def __getattr__(name: str):
+    """Delegate private compatibility imports to the shared implementation."""
+    return getattr(_shared, name)

mce220_runner/beam_search_model2/llmstr_to_vector.py

@@ -0,0 +1,104 @@
+"""
+Parse common information-theoretic inequality shorthands into entropy vectors.
+
+Supported:
+  - I(X_A;X_B|X_C)
+  - I(X_A;X_B)
+  - H(X_A|X_B)
+  - H(X_A) / H(X_{...}) linear combinations are handled by data/entropy_vector_converter.string_to_vector
+
+This module provides polym_ineq_to_vector(expr, n) to match existing imports.
+"""
+
+from __future__ import annotations
+
+import re
+import numpy as np
+from scipy.sparse import csr_matrix
+from typing import List, Set
+
+
+def _subset_to_index(subset: Set[int], n: int) -> int:
+    # Convert subset {i} into 0-based index in length (2^n - 1) vector.
+    # index = sum(2^(i-1)) - 1
+    s = 0
+    for i in subset:
+        if 1 <= i <= n:
+            s += 2 ** (i - 1)
+        else:
+            raise ValueError(f"variable index out of range: {i} (n={n})")
+    if s <= 0:
+        raise ValueError("empty subset has no entropy coordinate")
+    return s - 1
+
+
+def _parse_X_term(s: str) -> Set[int]:
+    """
+    Parse X_{1,2} or X_1 or {1,2} into a set of ints.
+    """
+    s = s.strip()
+    # Allow raw "{1,2}" or "1,2"
+    s = s.strip("{}")
+    s = s.replace("X_", "").strip()
+    if not s:
+        return set()
+    parts = [p.strip() for p in s.split(",") if p.strip()]
+    out: Set[int] = set()
+    for p in parts:
+        out.add(int(p))
+    return out
+
+
+def _vec_for_H(subset: Set[int], n: int, coeff: float) -> csr_matrix:
+    M = 2 ** n - 1
+    arr = np.zeros(M, dtype=np.float64)
+    arr[_subset_to_index(subset, n)] = coeff
+    return csr_matrix(arr.reshape(1, -1))
+
+
+def polym_ineq_to_vector(expr: str, n: int) -> csr_matrix:
+    """
+    Convert shorthand info-theoretic expressions into an entropy vector.
+
+    Note: caller is expected to strip any trailing ">=0" etc.
+    """
+    s = expr.replace(" ", "").strip()
+
+    # H(X_A|X_B) = H(A∪B) - H(B)
+    m = re.fullmatch(r"H\(X_(\{[^}]+\}|\d+)\|X_(\{[^}]+\}|\d+)\)", s)
+    if m:
+        A = _parse_X_term(m.group(1))
+        B = _parse_X_term(m.group(2))
+        if not A:
+            raise ValueError(f"invalid conditional entropy: {expr}")
+        return _vec_for_H(A | B, n, 1.0) + _vec_for_H(B, n, -1.0)
+
+    # I(X_A;X_B|X_C) = H(A∪C)+H(B∪C)-H(C)-H(A∪B∪C)
+    m = re.fullmatch(
+        r"I\(X_(\{[^}]+\}|\d+);X_(\{[^}]+\}|\d+)\|X_(\{[^}]+\}|\d+)\)", s
+    )
+    if m:
+        A = _parse_X_term(m.group(1))
+        B = _parse_X_term(m.group(2))
+        C = _parse_X_term(m.group(3))
+        if not A or not B:
+            raise ValueError(f"invalid conditional mutual information: {expr}")
+        return (
+            _vec_for_H(A | C, n, 1.0)
+            + _vec_for_H(B | C, n, 1.0)
+            + _vec_for_H(C, n, -1.0)
+            + _vec_for_H(A | B | C, n, -1.0)
+        )
+
+    # I(X_A;X_B) = H(A)+H(B)-H(A∪B)
+    m = re.fullmatch(r"I\(X_(\{[^}]+\}|\d+);X_(\{[^}]+\}|\d+)\)", s)
+    if m:
+        A = _parse_X_term(m.group(1))
+        B = _parse_X_term(m.group(2))
+        if not A or not B:
+            raise ValueError(f"invalid mutual information: {expr}")
+        return _vec_for_H(A, n, 1.0) + _vec_for_H(B, n, 1.0) + _vec_for_H(A | B, n, -1.0)
+
+    raise ValueError(f"Unsupported polymatroid shorthand: {expr}")
+
+

mce220_runner/beam_search_model2/run_on_window_shear_jsonl_v12.py

@@ -0,0 +1,821 @@
+#!/usr/bin/env python3
+"""
+Batch-run beam_search tree_search on a JSONL dataset using V12 logic.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+
+EXECUTION_CONFIG_SCHEMA_VERSION = "e2n-execution-config-v1"
+
+
+def _is_fatal_gpu_failure(exc: BaseException) -> bool:
+    """Return true for accelerator OOMs or abruptly terminated model workers."""
+
+    current: BaseException | None = exc
+    seen: set[int] = set()
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        class_name = type(current).__name__.lower()
+        message = str(current).lower()
+        if "brokenprocesspool" in class_name or "outofmemory" in class_name:
+            return True
+        if any(
+            fragment in message
+            for fragment in (
+                "cuda out of memory",
+                "cuda error: out of memory",
+                "hip out of memory",
+                "cublas_status_alloc_failed",
+                "cudnn_status_alloc_failed",
+                "process in the process pool was terminated abruptly",
+            )
+        ):
+            return True
+        current = current.__cause__ or current.__context__
+    return False
+
+try:
+    from verify_proof_certificate import verify_certificate
+except ModuleNotFoundError:
+    from beam_search_model2.verify_proof_certificate import verify_certificate
+
+
+def _proof_trace_metrics(vec, score_fn) -> Dict[str, Any]:
+    import numpy as np
+
+    data = np.asarray(vec.data, dtype=float) if vec is not None else np.asarray([], dtype=float)
+    return {
+        "negative_l1": float(np.abs(data[data < 0]).sum()) if data.size else 0.0,
+        "nnz": int(vec.nnz) if vec is not None else 0,
+        "score": float(score_fn(vec)),
+    }
+
+
+def build_proof_trace(
+    target_inequality: str,
+    n: int,
+    selected_steps,
+    *,
+    search_reported_proved: bool,
+) -> Dict[str, Any]:
+    """Reconstruct a compact, auditable residual trajectory from a selected path."""
+    try:
+        from Data_Generation_via_LLM_Guided_Search_v12 import (
+            _get_residual_score,
+            parse_cand_to_vector,
+            vector_to_string,
+        )
+    except ModuleNotFoundError:
+        from beam_search_model2.Data_Generation_via_LLM_Guided_Search_v12 import (
+            _get_residual_score,
+            parse_cand_to_vector,
+            vector_to_string,
+        )
+
+    residual = parse_cand_to_vector(target_inequality, n)
+    trace_steps = []
+    for index, inequality in enumerate(selected_steps or [], start=1):
+        before = residual
+        after = before - parse_cand_to_vector(str(inequality), n)
+        before_metrics = _proof_trace_metrics(before, _get_residual_score)
+        after_metrics = _proof_trace_metrics(after, _get_residual_score)
+        trace_steps.append(
+            {
+                "index": index,
+                "inequality": str(inequality),
+                "residual_before": vector_to_string(before),
+                "residual_after": vector_to_string(after),
+                "before": before_metrics,
+                "after": after_metrics,
+                "score_improvement": before_metrics["score"] - after_metrics["score"],
+            }
+        )
+        residual = after
+
+    terminal_metrics = _proof_trace_metrics(residual, _get_residual_score)
+    if terminal_metrics["nnz"] == 0:
+        certificate_kind = "zero_residual"
+    elif residual is not None and (residual.data >= -1e-9).all():
+        certificate_kind = "coefficientwise_nonnegative"
+    elif search_reported_proved:
+        certificate_kind = "reported_proved_without_explicit_certificate"
+    else:
+        certificate_kind = "not_certified"
+    return {
+        "steps": trace_steps,
+        "terminal": {
+            "residual": vector_to_string(residual),
+            **terminal_metrics,
+            "certificate_kind": certificate_kind,
+        },
+    }
+
+
+def attach_proof_trace(
+    run_output: Dict[str, Any],
+    target_inequality: str,
+    n: int,
+    selected_steps,
+    *,
+    search_reported_proved: bool,
+) -> None:
+    """Attach a trace without allowing diagnostic failure to abort a batch."""
+    try:
+        run_output["proof_trace"] = build_proof_trace(
+            target_inequality,
+            n,
+            selected_steps,
+            search_reported_proved=search_reported_proved,
+        )
+    except Exception as exc:
+        run_output["proof_trace_error"] = f"{type(exc).__name__}: {exc}"
+
+
+def _exact_verification_summary(result) -> Dict[str, Any]:
+    """Convert an exact verifier result into stable JSON-compatible diagnostics."""
+    return {
+        "status": "valid" if result.valid else "invalid",
+        "valid": bool(result.valid),
+        "reason": result.reason,
+        "terminal_kind": result.terminal_kind,
+        "step_count": len(result.steps),
+        "steps": [
+            {
+                "kind": step.kind,
+                "multiplier": str(step.multiplier),
+                "condition_index": step.condition_index,
+            }
+            for step in result.steps
+        ],
+        "residual": [
+            {"subset_mask": mask, "coefficient": str(coefficient)}
+            for mask, coefficient in sorted(result.residual.items())
+        ],
+    }
+
+
+def apply_exact_verification_gate(
+    run_output: Dict[str, Any],
+    target_inequality: str,
+    conditions,
+    n: int,
+    selected_steps,
+    *,
+    search_reported_proved: bool,
+) -> None:
+    """Require an exact symbolic certificate for every search-reported success."""
+    if not search_reported_proved:
+        return
+    verification_start = time.perf_counter()
+    try:
+        result = verify_certificate(
+            n,
+            target_inequality,
+            list(conditions or []),
+            list(selected_steps) if isinstance(selected_steps, list) else selected_steps,
+        )
+        summary = _exact_verification_summary(result)
+    except Exception as exc:
+        summary = {
+            "status": "error",
+            "valid": False,
+            "reason": f"{type(exc).__name__}: {exc}",
+            "terminal_kind": None,
+            "step_count": len(selected_steps) if isinstance(selected_steps, list) else 0,
+            "steps": [],
+            "residual": [],
+        }
+    summary["time_sec"] = max(time.perf_counter() - verification_start, 0.0)
+    run_output["exact_verification"] = summary
+    if summary["valid"]:
+        run_output["proved"] = True
+        return
+
+    run_output["proved"] = False
+    failure = f"Exact verification {summary['status']}: {summary['reason']}"
+    existing_error = run_output.get("error")
+    run_output["error"] = f"{existing_error}; {failure}" if existing_error else failure
+
+
+def _parse_per_n_budget(spec: str) -> Dict[int, Tuple[int, float]]:
+    budgets: Dict[int, Tuple[int, float]] = {}
+    raw_spec = (spec or "").strip()
+    if not raw_spec:
+        return budgets
+
+    for chunk in raw_spec.split(";"):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        try:
+            n_str, caps_str = chunk.split(":", 1)
+            tree_str, time_str = [part.strip() for part in caps_str.split(",", 1)]
+            budgets[int(n_str.strip())] = (int(tree_str), float(time_str))
+        except Exception as exc:
+            raise SystemExit(
+                "Invalid --per-n-budget format. Expected '8:3134,1130;9:3192,1499'. "
+                f"Failed at chunk {chunk!r}: {exc}"
+            )
+    return budgets
+
+
+def _resolve_sample_budget(
+    n: int,
+    per_n_budget: Dict[int, Tuple[int, float]],
+    fallback_tree_size: int,
+    fallback_time_sec: float,
+) -> Tuple[int, float]:
+    if n in per_n_budget:
+        return per_n_budget[n]
+    return fallback_tree_size, fallback_time_sec
+
+
+def _direct_execution_config(args: argparse.Namespace) -> Dict[str, Any]:
+    """Self-describe direct runner use when no reviewer wrapper is present."""
+
+    gpu_ids = []
+    raw_gpu_ids = str(
+        args.gpu_devices or os.environ.get("CUDA_VISIBLE_DEVICES") or ""
+    ).strip()
+    if raw_gpu_ids:
+        gpu_ids = [
+            int(part.strip())
+            for part in raw_gpu_ids.replace(" ", ",").split(",")
+            if part.strip()
+        ][: int(args.gpu_workers or 0)]
+    elif args.gpu_workers:
+        gpu_ids = list(range(int(args.gpu_workers)))
+    normalized = list(sys.argv)
+    if "--execution-config-manifest" in normalized:
+        index = normalized.index("--execution-config-manifest")
+        if index + 1 < len(normalized):
+            normalized[index + 1] = "<live-wrapper-manifest>"
+    return {
+        "schema_version": EXECUTION_CONFIG_SCHEMA_VERSION,
+        "invocation_id": uuid.uuid4().hex,
+        "recorded_utc": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "origin": "direct_runner",
+        "code": {
+            "git_commit": None,
+            "repo_root": None,
+            "runner_path": str(Path(__file__).resolve()),
+            "runner_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+        },
+        "model": {
+            "checkpoint_path": str(Path(args.adapter_path).expanduser().resolve())
+            if args.adapter_path
+            else None,
+            "checkpoint_sha256": None,
+            "base_model": None,
+        },
+        "search": {
+            key: value
+            for key, value in vars(args).items()
+            if key != "execution_config_manifest"
+        },
+        "resources": {
+            "workers": int(args.gpu_workers or 0),
+            "gpu_ids": gpu_ids,
+            "worker_device_mapping": [
+                {
+                    "worker_index": index,
+                    "physical_gpu_index": gpu_id,
+                    "gpu_uuid": None,
+                }
+                for index, gpu_id in enumerate(gpu_ids)
+            ],
+            "cuda_visible_devices": os.environ.get("CUDA_VISIBLE_DEVICES"),
+            "launch_gpu_snapshot": [],
+        },
+        "normalized_command": normalized,
+    }
+
+
+def _load_execution_config(
+    manifest_path: str, args: argparse.Namespace
+) -> Dict[str, Any]:
+    if not manifest_path:
+        return _direct_execution_config(args)
+    path = Path(manifest_path).expanduser().resolve()
+    try:
+        manifest = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise SystemExit(f"Invalid --execution-config-manifest: {exc}") from exc
+    config = manifest.get("execution_config") if isinstance(manifest, dict) else None
+    if not isinstance(config, dict):
+        raise SystemExit("Execution-config manifest has no object execution_config")
+    if config.get("schema_version") != EXECUTION_CONFIG_SCHEMA_VERSION:
+        raise SystemExit(
+            "Unsupported execution_config schema: "
+            f"{config.get('schema_version')!r}"
+        )
+    required = {
+        "invocation_id",
+        "recorded_utc",
+        "origin",
+        "code",
+        "model",
+        "search",
+        "resources",
+        "normalized_command",
+    }
+    missing = sorted(required.difference(config))
+    if missing:
+        raise SystemExit(f"Execution config is missing fields: {missing}")
+    # Round-trip once so every row receives a detached, JSON-safe value.
+    return json.loads(json.dumps(config, ensure_ascii=False))
+
+
+def _append_jsonl_row(path: Path, row: Dict[str, Any]) -> None:
+    """Append one complete row with one O_APPEND write, then fsync it."""
+
+    payload = (json.dumps(row, ensure_ascii=False) + "\n").encode("utf-8")
+    descriptor = os.open(
+        path,
+        os.O_WRONLY | os.O_CREAT | os.O_APPEND,
+        0o600,
+    )
+    try:
+        written = os.write(descriptor, payload)
+        if written != len(payload):
+            raise OSError(
+                f"short atomic JSONL append: wrote {written} of {len(payload)} bytes"
+            )
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--input", required=True, help="Input JSONL path")
+    ap.add_argument("--output", required=True, help="Output JSONL path")
+    ap.add_argument(
+        "--execution-config-manifest",
+        default="",
+        help="Live wrapper manifest containing the effective execution_config.",
+    )
+    ap.add_argument("--max-depth", type=int, default=10)
+    ap.add_argument("--rollouts", type=int, default=2)
+    ap.add_argument(
+        "--k-per-node",
+        type=int,
+        default=1,
+        help=(
+            "Number of sequential LLM generate+append steps per node before one LP check "
+            "(default: 1)."
+        ),
+    )
+    ap.add_argument(
+        "--llm-mode",
+        choices=["sequential", "batch"],
+        default="sequential",
+        help="LLM generation mode: sequential (k conditioned steps) or batch (one GPU call returns k candidates).",
+    )
+    ap.add_argument(
+        "--lp-workers",
+        type=int,
+        default=0,
+        help=(
+            "Reserved for command-line compatibility. Current v12 LP checks are "
+            "synchronous; this value does not create an LP process pool."
+        ),
+    )
+    ap.add_argument(
+        "--gpu-workers",
+        type=int,
+        default=0,
+        help=(
+            "If >0, run depth-parallel LLM expansion using this many GPU worker processes "
+            "(one model instance per process / per GPU)."
+        ),
+    )
+    ap.add_argument(
+        "--gpu-devices",
+        default="",
+        help=(
+            "Comma-separated list of GPU ids to use for LLM workers (e.g. '0,1,2,3'). "
+            "If omitted, will try to infer from CUDA_VISIBLE_DEVICES."
+        ),
+    )
+    ap.add_argument("--limit", type=int, default=0, help="If >0, only run first N samples")
+    ap.add_argument(
+        "--min-n",
+        type=int,
+        default=0,
+        help="If >0, skip samples with fewer than this many variables.",
+    )
+    ap.add_argument(
+        "--max-n",
+        type=int,
+        default=0,
+        help="If >0, skip samples with more than this many variables.",
+    )
+    ap.add_argument(
+        "--adapter-path",
+        default=os.environ.get("QWEN_ADAPTER_PATH", ""),
+        help="Path to PEFT adapter dir (defaults to env QWEN_ADAPTER_PATH)",
+    )
+    ap.add_argument("--use-dummy", action="store_true", help="Use dummy LLM outputs (no model load)")
+    ap.add_argument(
+        "--max-new-tokens",
+        type=int,
+        default=int(os.environ.get("QWEN_MAX_NEW_TOKENS", "1024")),
+        help="LLM generation cap",
+    )
+    ap.add_argument(
+        "--max-time",
+        type=float,
+        default=float(os.environ.get("QWEN_MAX_TIME", "20.0")),
+        help="LLM generation time cap (seconds)",
+    )
+    ap.add_argument(
+        "--sample-max-time-sec",
+        type=float,
+        default=0.0,
+        help=(
+            "Soft cap on elapsed search time. Work already in flight can finish after "
+            "the limit."
+        ),
+    )
+    ap.add_argument(
+        "--sample-max-tree-size",
+        type=int,
+        default=0,
+        help="Soft cap on explored tree size, checked between completed expansions.",
+    )
+    ap.add_argument(
+        "--sample-max-llm-calls",
+        type=int,
+        default=0,
+        help=(
+            "Soft cap on aggregated LLM calls. Concurrent or multi-step expansions can "
+            "overshoot it."
+        ),
+    )
+    ap.add_argument(
+        "--sample-max-llm-fails",
+        type=int,
+        default=0,
+        help="If >0, stop a sample once llm_usage.format_fail_total reaches this limit.",
+    )
+    ap.add_argument(
+        "--depth1-rollouts",
+        type=int,
+        default=0,
+        help="If >0, override the special depth=1 rollout count (default keeps existing value 32).",
+    )
+    ap.add_argument(
+        "--per-n-budget",
+        default="",
+        help="Per-n tree/time caps in the form '8:3134,1130;9:3192,1499'.",
+    )
+    ap.add_argument(
+        "--append",
+        action="store_true",
+        help="Append to the output JSONL instead of overwriting it.",
+    )
+    ap.add_argument(
+        "--resume-from-output",
+        action="store_true",
+        help="Resume by skipping the first N eligible samples, where N is the number of existing rows in the output JSONL.",
+    )
+    ap.add_argument(
+        "--log-every",
+        type=int,
+        default=1,
+        help="Print progress every N samples (default: 1)",
+    )
+    ap.add_argument(
+        "--print-llm",
+        action="store_true",
+        help="Print raw LLM generation and extracted inequalities each call (to stderr)",
+    )
+    ap.add_argument(
+        "--debug-search",
+        action="store_true",
+        help="Enable extra debug printing from tree_search (LP status / parse warnings)",
+    )
+    ap.add_argument(
+        "--beam-size",
+        type=int,
+        default=0,
+        help="If >0, keep at most this many nodes (paths) per depth to avoid explosion",
+    )
+    ap.add_argument(
+        "--random-prune",
+        action="store_true",
+        help="When beam-size is exceeded, uniformly sample nodes without replacement.",
+    )
+    ap.add_argument(
+        "--include-proof-trace",
+        action="store_true",
+        help="Include residual and score diagnostics for every selected proof step.",
+    )
+    ap.add_argument(
+        "--prune-seed",
+        type=int,
+        default=0,
+        help="Seed for random pruning (0 means nondeterministic)",
+    )
+    ap.add_argument(
+        "--seed",
+        type=int,
+        default=0,
+        help="Global seed for random, numpy, and torch (0 means nondeterministic)",
+    )
+    ap.add_argument(
+        "--log-wrong-pruned",
+        action="store_true",
+        help="Enable logging of pruned model outputs (invalid/negative/malformed, including multi-term expressions) to a JSONL file",
+    )
+    ap.add_argument(
+        "--wrong-pruned-path",
+        type=str,
+        default="",
+        help="Path to write the pruned malformed / wrong expressions JSONL dataset",
+    )
+    ap.add_argument(
+        "--enable-lp",
+        action="store_true",
+        help="Enable Shannon LP check.",
+    )
+    ap.add_argument(
+        "--max-vars-for-lp",
+        type=int,
+        default=6,
+        help="Maximum number of variables for full Shannon LP check (default: 6)",
+    )
+    args = ap.parse_args()
+    execution_config = _load_execution_config(args.execution_config_manifest, args)
+
+    if args.lp_workers and args.lp_workers > 0:
+        print(
+            "warning: --lp-workers is retained for compatibility but is not implemented "
+            "by the v12 search; LP checks remain synchronous",
+            file=sys.stderr,
+        )
+
+    if args.seed and args.seed != 0:
+        import random as _random
+        import numpy as _np
+        import torch as _torch
+        _random.seed(args.seed)
+        _np.random.seed(args.seed)
+        _torch.manual_seed(args.seed)
+        _torch.cuda.manual_seed_all(args.seed)
+        print(f"Global seed set to {args.seed}")
+
+    per_n_budget = _parse_per_n_budget(args.per_n_budget)
+    depth1_rollouts = args.depth1_rollouts if args.depth1_rollouts > 0 else None
+    budget_enabled = bool(per_n_budget) or any(
+        [
+            (args.sample_max_time_sec and args.sample_max_time_sec > 0),
+            (args.sample_max_tree_size and args.sample_max_tree_size > 0),
+            (args.sample_max_llm_calls and args.sample_max_llm_calls > 0),
+            (args.sample_max_llm_fails and args.sample_max_llm_fails > 0),
+            (depth1_rollouts is not None),
+        ]
+    )
+
+    gpu_devices = None
+    if args.gpu_workers and args.gpu_workers > 0:
+        dev_str = (args.gpu_devices or "").strip()
+        if not dev_str:
+            dev_str = (os.environ.get("CUDA_VISIBLE_DEVICES") or "").strip()
+        if dev_str:
+            parts = [p.strip() for p in dev_str.replace(" ", ",").split(",") if p.strip()]
+            try:
+                gpu_devices = [int(p) for p in parts]
+            except Exception:
+                raise SystemExit(f"Invalid --gpu-devices / CUDA_VISIBLE_DEVICES format: {dev_str!r}")
+        else:
+            gpu_devices = list(range(int(args.gpu_workers)))
+
+        if len(gpu_devices) < int(args.gpu_workers):
+            raise SystemExit(
+                f"--gpu-workers={args.gpu_workers} but only {len(gpu_devices)} devices provided: {gpu_devices}"
+            )
+        gpu_devices = gpu_devices[: int(args.gpu_workers)]
+
+    from Data_Generation_via_LLM_Guided_Search_v12 import Node, tree_search
+
+    in_path = Path(args.input)
+    out_path = Path(args.output)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if args.log_wrong_pruned and not args.wrong_pruned_path:
+        args.wrong_pruned_path = str(out_path.parent / (out_path.stem + "_wrong_pruned.jsonl"))
+
+    total = 0
+    proved_cnt = 0
+    t_start = time.perf_counter()
+    resume_skip_remaining = 0
+    if args.resume_from_output and out_path.exists():
+        with out_path.open("r", encoding="utf-8") as existing_f:
+            resume_skip_remaining = sum(1 for line in existing_f if line.strip())
+        if resume_skip_remaining:
+            print(
+                f"Resuming from existing output: skipping first {resume_skip_remaining} eligible samples from {out_path}"
+            )
+
+    try:
+        if not args.append:
+            descriptor = os.open(
+                out_path,
+                os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                0o600,
+            )
+            try:
+                os.fsync(descriptor)
+            finally:
+                os.close(descriptor)
+        with in_path.open("r", encoding="utf-8") as fin:
+            for source_line_number, line in enumerate(fin, start=1):
+                line = line.strip()
+                if not line:
+                    continue
+                input_sha256 = hashlib.sha256(line.encode("utf-8")).hexdigest()
+
+                obj: Dict[str, Any] = json.loads(line)
+                n = int(obj["n"])
+                if args.min_n and n < args.min_n:
+                    continue
+                if args.max_n and n > args.max_n:
+                    continue
+                if resume_skip_remaining > 0:
+                    resume_skip_remaining -= 1
+                    continue
+                ineq = str(obj["ineq"])
+                conditions = obj.get("conditions", [])
+
+                ineq_map, conds_map, mapping = ineq, conditions, {}
+                tree_cap, time_cap = _resolve_sample_budget(
+                    n=n,
+                    per_n_budget=per_n_budget,
+                    fallback_tree_size=args.sample_max_tree_size,
+                    fallback_time_sec=args.sample_max_time_sec,
+                )
+                llm_cap = int(args.sample_max_llm_calls or 0)
+                llm_fail_cap = int(args.sample_max_llm_fails or 0)
+
+                root = Node()
+                t0 = time.perf_counter()
+                try:
+                    os.environ["QWEN_MAX_NEW_TOKENS"] = str(args.max_new_tokens)
+                    os.environ["QWEN_MAX_TIME"] = str(args.max_time)
+                    os.environ["QWEN_PRINT_OUTPUT"] = "1" if args.print_llm else "0"
+                    os.environ["BEAM_DEBUG"] = "1" if args.debug_search else "0"
+                    if args.lp_workers and args.lp_workers > 0:
+                        os.environ.setdefault("OMP_NUM_THREADS", "1")
+                        os.environ.setdefault("MKL_NUM_THREADS", "1")
+                        os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
+
+                    proved, tree, x, expr_str, llm_usage, stop_reason = tree_search(
+                        root_node=root,
+                        max_depth=args.max_depth,
+                        rollout_count=args.rollouts,
+                        target_inequality=ineq_map,
+                        conditions=conds_map,
+                        n=n,
+                        adapter_path=(args.adapter_path or None),
+                        use_dummy=args.use_dummy,
+                        k_per_call=args.k_per_node,
+                        llm_mode=args.llm_mode,
+                        lp_workers=args.lp_workers,
+                        gpu_devices=gpu_devices,
+                        beam_size=args.beam_size,
+                        random_prune=args.random_prune,
+                        prune_seed=(args.prune_seed if args.prune_seed != 0 else None),
+                        max_vars_for_lp=(args.max_vars_for_lp if args.enable_lp else 0),
+                        log_wrong_pruned=args.log_wrong_pruned,
+                        wrong_pruned_path=args.wrong_pruned_path,
+                        sample_time_budget_sec=time_cap,
+                        sample_tree_budget=tree_cap,
+                        sample_llm_calls_budget=llm_cap,
+                        sample_llm_fail_budget=llm_fail_cap,
+                        depth1_rollouts=depth1_rollouts,
+                    )
+                    err = None
+                except Exception as e:
+                    proved, tree, x, expr_str, llm_usage, stop_reason = False, None, None, None, None, None
+                    err = f"{type(e).__name__}: {e}"
+                    fatal_gpu_failure = _is_fatal_gpu_failure(e)
+                    if fatal_gpu_failure:
+                        stop_reason = "fatal_gpu_failure"
+                else:
+                    fatal_gpu_failure = False
+
+                search_dt = time.perf_counter() - t0
+                total += 1
+                search_reported_proved = bool(proved)
+
+                out_obj = {
+                    "source_line_number": source_line_number,
+                    "input_sha256": input_sha256,
+                    "input": obj,
+                    "mapped": {"ineq": ineq_map, "n": n, "mapping": mapping},
+                    "run": {
+                        "proved": bool(proved),
+                        "time_sec": search_dt,
+                        "search_time_sec": search_dt,
+                        "tree_size": len(tree) if tree is not None else 0,
+                        "expr_str": expr_str,
+                        "x": x.tolist() if hasattr(x, "tolist") else x,
+                        "error": err,
+                        "llm_usage": llm_usage or {},
+                        "execution_config": execution_config,
+                    },
+                }
+                apply_exact_verification_gate(
+                    out_obj["run"],
+                    ineq_map,
+                    conds_map,
+                    n,
+                    expr_str,
+                    search_reported_proved=search_reported_proved,
+                )
+                proved = bool(out_obj["run"]["proved"])
+                proved_cnt += int(proved)
+                if args.include_proof_trace:
+                    attach_proof_trace(
+                        out_obj["run"],
+                        ineq_map,
+                        n,
+                        expr_str,
+                        search_reported_proved=search_reported_proved,
+                    )
+                if budget_enabled:
+                    out_obj["run"]["stop_reason"] = stop_reason
+                    out_obj["run"]["budget_applied"] = {
+                        "tree_size": int(tree_cap or 0),
+                        "time_sec": float(time_cap or 0.0),
+                        "llm_calls": llm_cap,
+                        "llm_fails": llm_fail_cap,
+                        "depth1_rollouts": depth1_rollouts,
+                        "enforcement": "soft_post_expansion",
+                    }
+                elif fatal_gpu_failure:
+                    out_obj["run"]["stop_reason"] = stop_reason
+                dt = time.perf_counter() - t0
+                out_obj["run"]["time_sec"] = dt
+                _append_jsonl_row(out_path, out_obj)
+
+                if fatal_gpu_failure:
+                    sys.stderr.write(
+                        "[runner] Fatal GPU OOM or worker crash; result prefix was "
+                        "flushed and no further sample will be started.\n"
+                    )
+                    sys.stderr.flush()
+                    return 12
+
+                if stop_reason in {"llm_fail_budget", "format_fail_budget"}:
+                    sys.stderr.write(
+                        "\n[runner] Sample hit format_fail_total budget. Exiting checkpoint evaluation.\n"
+                    )
+                    sys.exit(10)
+
+                if args.log_every and (total % args.log_every == 0):
+                    now = time.perf_counter()
+                    elapsed = now - t_start
+                    avg = elapsed / max(total, 1)
+                    msg = (
+                        f"[progress] {total} samples | proved={proved_cnt} | "
+                        f"last={dt:.2f}s avg={avg:.2f}s | "
+                        f"max_depth={args.max_depth} rollouts={args.rollouts} "
+                        f"max_new_tokens={args.max_new_tokens} max_time={args.max_time}"
+                    )
+                    if stop_reason:
+                        msg += f" | stop_reason={stop_reason}"
+                    meta = obj.get("meta") if isinstance(obj, dict) else None
+                    if isinstance(meta, dict):
+                        msg += f" | seed={meta.get('master_seed')} idx={meta.get('index_within_type')}"
+                    msg += "\n"
+                    sys.stderr.write(msg)
+                    sys.stderr.flush()
+
+                if args.limit and total >= args.limit:
+                    break
+    except KeyboardInterrupt:
+        print(f"\nInterrupted. partial output saved to {out_path}")
+
+    print(f"Done. total={total} proved={proved_cnt} output={out_path}")
+    if args.log_wrong_pruned:
+        print(f"Wrong expressions logged to: {args.wrong_pruned_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mce220_runner/beam_search_model2/verify_proof_certificate.py

@@ -0,0 +1,557 @@
+#!/usr/bin/env python3
+"""Exact, standalone verifier for v12 entropy proof certificates.
+
+The verifier deliberately does not import the search implementation.  It parses
+the emitted symbolic expressions into sparse maps whose keys are nonempty
+subset masks and whose values are :class:`fractions.Fraction` objects.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass
+from fractions import Fraction
+from pathlib import Path
+from typing import Dict, List, Mapping, Optional, Sequence, Tuple
+
+
+Vector = Dict[int, Fraction]
+
+_NUMBER = r"(?:\d+(?:\.\d*)?|\.\d+)"
+_NUMBER_RE = re.compile(_NUMBER)
+_COMPARATOR_RE = re.compile(r"(>=|<=|=|>|<)\s*0(?:\.0*)?\s*$")
+_VARIABLE_RE = re.compile(r"X_(?:\{(\d+(?:,\d+)*)\}|(\d+))")
+
+
+class ProofCertificateError(ValueError):
+    """Base class for a malformed certificate or result row."""
+
+
+class ProofSyntaxError(ProofCertificateError):
+    """An entropy expression is outside the verifier's accepted grammar."""
+
+
+@dataclass(frozen=True)
+class Atom:
+    kind: str
+    groups: Tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class ParsedExpression:
+    vector: Vector
+    atom: Optional[Atom]
+    atom_coefficient: Optional[Fraction]
+
+
+@dataclass(frozen=True)
+class ParsedConstraint:
+    expression: ParsedExpression
+    comparator: str
+
+
+@dataclass(frozen=True)
+class VerifiedStep:
+    expression: str
+    kind: str
+    multiplier: Fraction
+    condition_index: Optional[int] = None
+
+
+@dataclass(frozen=True)
+class VerificationResult:
+    valid: bool
+    reason: str
+    steps: Tuple[VerifiedStep, ...]
+    residual: Vector
+    terminal_kind: Optional[str]
+
+
+def _clean(vector: Mapping[int, Fraction]) -> Vector:
+    return {mask: value for mask, value in vector.items() if value}
+
+
+def _add(target: Vector, source: Mapping[int, Fraction], scale: Fraction = Fraction(1)) -> None:
+    for mask, value in source.items():
+        new_value = target.get(mask, Fraction(0)) + scale * value
+        if new_value:
+            target[mask] = new_value
+        else:
+            target.pop(mask, None)
+
+
+def _scaled(vector: Mapping[int, Fraction], scale: Fraction) -> Vector:
+    return _clean({mask: scale * value for mask, value in vector.items()})
+
+
+def _parse_scalar(text: str) -> Fraction:
+    if text in ("", "+"):
+        return Fraction(1)
+    if text == "-":
+        return Fraction(-1)
+    if not re.fullmatch(rf"[+-]?{_NUMBER}", text):
+        raise ProofSyntaxError(f"invalid rational coefficient {text!r}")
+    # Fraction parses decimal strings exactly (for example, 0.1 as 1/10).
+    return Fraction(text)
+
+
+def _matching_paren(text: str, opening: int) -> int:
+    depth = 0
+    for index in range(opening, len(text)):
+        char = text[index]
+        if char == "(":
+            depth += 1
+        elif char == ")":
+            depth -= 1
+            if depth == 0:
+                return index
+            if depth < 0:
+                break
+    raise ProofSyntaxError(f"unbalanced parentheses near {text[opening:]!r}")
+
+
+def _outer_scalar(text: str) -> Optional[Tuple[Fraction, str]]:
+    opening = text.find("(")
+    if opening < 0 or _matching_paren(text, opening) != len(text) - 1:
+        return None
+    prefix = text[:opening]
+    # H(...) and I(...) are atoms, not grouping parentheses.
+    if prefix in ("H", "I"):
+        return None
+    if prefix.endswith("*"):
+        prefix = prefix[:-1]
+        if not prefix:
+            raise ProofSyntaxError("a '*' before a grouped expression needs a coefficient")
+    if prefix and not re.fullmatch(rf"[+-]?(?:{_NUMBER})?", prefix):
+        return None
+    return _parse_scalar(prefix), text[opening + 1 : -1]
+
+
+def _parse_variable_group(text: str, n: int) -> int:
+    if not text:
+        raise ProofSyntaxError("an information term contains an empty variable group")
+    mask = 0
+    position = 0
+    found = False
+    for match in _VARIABLE_RE.finditer(text):
+        gap = text[position : match.start()]
+        if gap not in ("", ","):
+            raise ProofSyntaxError(f"invalid variable-group syntax {text!r}")
+        indices = (match.group(1) or match.group(2)).split(",")
+        for raw_index in indices:
+            index = int(raw_index)
+            if index < 1 or index > n:
+                raise ProofSyntaxError(
+                    f"variable X_{index} is outside the declared range 1..{n}"
+                )
+            mask |= 1 << (index - 1)
+        position = match.end()
+        found = True
+    if not found or position != len(text):
+        raise ProofSyntaxError(f"invalid variable-group syntax {text!r}")
+    return mask
+
+
+def _entropy(mask: int, coefficient: Fraction = Fraction(1)) -> Vector:
+    return {} if not mask or not coefficient else {mask: coefficient}
+
+
+def _parse_atom(text: str, n: int) -> Tuple[Vector, Atom]:
+    if len(text) < 3 or text[0] not in "HI" or text[1] != "(":
+        raise ProofSyntaxError(f"expected H(...) or I(...), found {text!r}")
+    if _matching_paren(text, 1) != len(text) - 1:
+        raise ProofSyntaxError(f"unexpected text after information term {text!r}")
+
+    kind = text[0]
+    inside = text[2:-1]
+    if kind == "H":
+        parts = inside.split("|")
+        if len(parts) > 2:
+            raise ProofSyntaxError(f"too many conditioning bars in {text!r}")
+        left = _parse_variable_group(parts[0], n)
+        if len(parts) == 1:
+            return _entropy(left), Atom("entropy", (left,))
+        conditioning = _parse_variable_group(parts[1], n)
+        vector = _entropy(left | conditioning)
+        _add(vector, _entropy(conditioning), Fraction(-1))
+        return vector, Atom("conditional_entropy", (left, conditioning))
+
+    conditional_parts = inside.split("|")
+    if len(conditional_parts) > 2:
+        raise ProofSyntaxError(f"too many conditioning bars in {text!r}")
+    sides = conditional_parts[0].split(";")
+    if len(sides) != 2:
+        raise ProofSyntaxError(f"mutual information requires two ';'-separated groups in {text!r}")
+    left = _parse_variable_group(sides[0], n)
+    right = _parse_variable_group(sides[1], n)
+    conditioning = (
+        _parse_variable_group(conditional_parts[1], n)
+        if len(conditional_parts) == 2
+        else 0
+    )
+    vector: Vector = {}
+    _add(vector, _entropy(left | conditioning))
+    _add(vector, _entropy(right | conditioning))
+    _add(vector, _entropy(left | right | conditioning), Fraction(-1))
+    _add(vector, _entropy(conditioning), Fraction(-1))
+    atom_kind = "conditional_mutual_information" if conditioning else "mutual_information"
+    return vector, Atom(atom_kind, (left, right, conditioning))
+
+
+def parse_expression(text: str, n: int) -> ParsedExpression:
+    """Parse a linear entropy expression into exact sparse coordinates."""
+    if not isinstance(text, str):
+        raise ProofSyntaxError("an entropy expression must be a string")
+    if not isinstance(n, int) or isinstance(n, bool) or n < 1:
+        raise ProofSyntaxError(f"n must be a positive integer, found {n!r}")
+    compact = re.sub(r"\s+", "", text)
+    if compact == "0":
+        return ParsedExpression({}, None, None)
+    if not compact:
+        raise ProofSyntaxError("empty entropy expression")
+
+    outer = _outer_scalar(compact)
+    outer_coefficient = Fraction(1)
+    if outer is not None:
+        outer_coefficient, compact = outer
+        if not compact:
+            raise ProofSyntaxError("empty parenthesized expression")
+
+    vector: Vector = {}
+    atoms: List[Tuple[Atom, Fraction]] = []
+    position = 0
+    while position < len(compact):
+        sign = Fraction(1)
+        if compact[position] in "+-":
+            sign = Fraction(-1) if compact[position] == "-" else Fraction(1)
+            position += 1
+            if position == len(compact):
+                raise ProofSyntaxError("expression ends with a sign")
+        elif position != 0:
+            raise ProofSyntaxError(f"expected '+' or '-' at offset {position}")
+
+        number_match = _NUMBER_RE.match(compact, position)
+        coefficient = Fraction(1)
+        if number_match:
+            coefficient = Fraction(number_match.group(0))
+            position = number_match.end()
+            if position < len(compact) and compact[position] == "*":
+                position += 1
+        elif position < len(compact) and compact[position] == "*":
+            raise ProofSyntaxError(f"unexpected '*' at offset {position}")
+
+        if position >= len(compact) or compact[position] not in "HI":
+            raise ProofSyntaxError(f"expected H(...) or I(...) at offset {position}")
+        opening = position + 1
+        if opening >= len(compact) or compact[opening] != "(":
+            raise ProofSyntaxError(f"expected '(' after {compact[position]!r}")
+        closing = _matching_paren(compact, opening)
+        atom_vector, atom = _parse_atom(compact[position : closing + 1], n)
+        term_coefficient = sign * coefficient * outer_coefficient
+        _add(vector, atom_vector, term_coefficient)
+        atoms.append((atom, term_coefficient))
+        position = closing + 1
+
+    single_atom = atoms[0][0] if len(atoms) == 1 else None
+    single_coefficient = atoms[0][1] if len(atoms) == 1 else None
+    return ParsedExpression(vector, single_atom, single_coefficient)
+
+
+def parse_constraint(
+    text: str,
+    n: int,
+    *,
+    default_comparator: Optional[str] = None,
+) -> ParsedConstraint:
+    """Parse an expression followed by an optional comparison with zero."""
+    if not isinstance(text, str):
+        raise ProofSyntaxError("a constraint must be a string")
+    match = _COMPARATOR_RE.search(text)
+    if match:
+        lhs = text[: match.start()]
+        comparator = match.group(1)
+        if any(op in lhs for op in (">", "<", "=")):
+            raise ProofSyntaxError(f"unexpected comparator in {text!r}")
+    else:
+        if any(op in text for op in (">", "<", "=")):
+            raise ProofSyntaxError(f"constraints must compare against zero: {text!r}")
+        if default_comparator is None:
+            raise ProofSyntaxError(f"missing comparator in {text!r}")
+        lhs = text
+        comparator = default_comparator
+    if comparator not in (">=", "<=", "=", ">", "<"):
+        raise ProofSyntaxError(f"unsupported comparator {comparator!r}")
+    return ParsedConstraint(parse_expression(lhs, n), comparator)
+
+
+def _oriented_vector(constraint: ParsedConstraint) -> Vector:
+    if constraint.comparator in ("<=", "<"):
+        return _scaled(constraint.expression.vector, Fraction(-1))
+    return dict(constraint.expression.vector)
+
+
+def _multiple(left: Mapping[int, Fraction], right: Mapping[int, Fraction]) -> Optional[Fraction]:
+    """Return q when left == q * right, or None for nonmultiples/zero rows."""
+    left = _clean(left)
+    right = _clean(right)
+    if not left or not right or set(left) != set(right):
+        return None
+    first_mask = next(iter(right))
+    ratio = left[first_mask] / right[first_mask]
+    if ratio == 0:
+        return None
+    if all(left[mask] == ratio * right[mask] for mask in right):
+        return ratio
+    return None
+
+
+@dataclass(frozen=True)
+class _ConditionFact:
+    vector: Vector
+    equality: bool
+    source_index: int
+
+
+def _condition_facts(conditions: Sequence[str], n: int) -> List[_ConditionFact]:
+    parsed: List[_ConditionFact] = []
+    for index, raw in enumerate(conditions):
+        sentinel = re.sub(r"\s+", "", raw).upper()
+        if sentinel in {"NONE", "NONE=0", "NONE>=0", "(NONE)", "(NONE)=0", "(NONE)>=0"}:
+            continue
+        condition = parse_constraint(raw, n, default_comparator=">=")
+        vector = _oriented_vector(condition)
+        if not vector:
+            raise ProofSyntaxError(f"condition {index + 1} has an identically zero left-hand side")
+        parsed.append(_ConditionFact(vector, condition.comparator == "=", index))
+
+    # Opposite one-sided rows jointly assert equality.  Promote both, matching
+    # the v12 search's condition normalization.
+    promoted = set()
+    for left_index, left in enumerate(parsed):
+        if left.equality:
+            continue
+        for right_index in range(left_index + 1, len(parsed)):
+            right = parsed[right_index]
+            ratio = _multiple(left.vector, right.vector)
+            if not right.equality and ratio is not None and ratio < 0:
+                promoted.update((left_index, right_index))
+    return [
+        _ConditionFact(fact.vector, fact.equality or index in promoted, fact.source_index)
+        for index, fact in enumerate(parsed)
+    ]
+
+
+def _classify_step(
+    raw_step: str,
+    n: int,
+    condition_facts: Sequence[_ConditionFact],
+) -> Tuple[Optional[VerifiedStep], Optional[str], Vector]:
+    step = parse_constraint(raw_step, n)
+    vector = dict(step.expression.vector)
+    if not vector:
+        return None, "step has an identically zero left-hand side", vector
+    if step.comparator in (">", "<"):
+        return None, "strict proof-step comparators are not accepted", vector
+    if step.comparator == "<=":
+        return None, "proof steps must be written in nonnegative (>=0) orientation", vector
+
+    if (
+        step.comparator == ">="
+        and step.expression.atom is not None
+        and step.expression.atom_coefficient is not None
+        and step.expression.atom_coefficient > 0
+    ):
+        return (
+            VerifiedStep(
+                raw_step,
+                "shannon_atom",
+                step.expression.atom_coefficient,
+                None,
+            ),
+            None,
+            vector,
+        )
+
+    for fact in condition_facts:
+        multiplier = _multiple(vector, fact.vector)
+        if multiplier is None:
+            continue
+        if fact.equality:
+            return (
+                VerifiedStep(raw_step, "equality_condition", multiplier, fact.source_index),
+                None,
+                vector,
+            )
+        if step.comparator == ">=" and multiplier > 0:
+            return (
+                VerifiedStep(raw_step, "inequality_condition", multiplier, fact.source_index),
+                None,
+                vector,
+            )
+
+    return None, "step is neither a positive Shannon atom nor an allowed condition multiple", vector
+
+
+def verify_certificate(
+    n: int,
+    target: str,
+    conditions: Sequence[str],
+    steps: Sequence[str],
+    *,
+    terminal_residual: Optional[str] = None,
+) -> VerificationResult:
+    """Verify a certificate exactly, returning a diagnostic result.
+
+    The terminal residual is recomputed as ``target - sum(steps)``.  When an
+    encoded terminal residual is supplied (for example from ``proof_trace``),
+    it must match that recomputation exactly.
+    """
+    target_constraint = parse_constraint(target, n, default_comparator=">=")
+    if target_constraint.comparator in (">", "<"):
+        return VerificationResult(False, "strict target comparators are not accepted", (), {}, None)
+    if target_constraint.comparator == "=":
+        return VerificationResult(False, "equality targets are not supported", (), {}, None)
+    target_vector = _oriented_vector(target_constraint)
+    facts = _condition_facts(list(conditions), n)
+
+    residual = dict(target_vector)
+    verified_steps: List[VerifiedStep] = []
+    for index, raw_step in enumerate(steps):
+        if not isinstance(raw_step, str):
+            raise ProofSyntaxError(f"step {index + 1} must be a string")
+        classified, reason, step_vector = _classify_step(raw_step, n, facts)
+        if classified is None:
+            return VerificationResult(
+                False,
+                f"step {index + 1}: {reason}",
+                tuple(verified_steps),
+                residual,
+                None,
+            )
+        verified_steps.append(classified)
+        _add(residual, step_vector, Fraction(-1))
+
+    residual = _clean(residual)
+    if terminal_residual is not None:
+        encoded = parse_expression(terminal_residual, n).vector
+        if encoded != residual:
+            return VerificationResult(
+                False,
+                "encoded terminal residual does not equal target minus accepted steps",
+                tuple(verified_steps),
+                residual,
+                None,
+            )
+
+    if not residual:
+        terminal_kind = "zero_residual"
+    elif all(coefficient >= 0 for coefficient in residual.values()):
+        terminal_kind = "coordinatewise_nonnegative"
+    else:
+        return VerificationResult(
+            False,
+            "terminal residual has a negative joint-entropy coordinate",
+            tuple(verified_steps),
+            residual,
+            None,
+        )
+
+    return VerificationResult(
+        True,
+        "certificate verified exactly",
+        tuple(verified_steps),
+        residual,
+        terminal_kind,
+    )
+
+
+def verify_result_row(row: Mapping[str, object]) -> VerificationResult:
+    """Verify one claimed-proof row in the v12 JSONL output schema."""
+    if not isinstance(row, Mapping):
+        raise ProofCertificateError("result row must be a JSON object")
+    run = row.get("run")
+    input_data = row.get("input")
+    mapped = row.get("mapped")
+    if not isinstance(run, Mapping) or not isinstance(input_data, Mapping):
+        raise ProofCertificateError("result row requires object-valued 'input' and 'run' fields")
+    if run.get("proved") is not True:
+        return VerificationResult(False, "row does not claim a proof", (), {}, None)
+
+    mapped_data = mapped if isinstance(mapped, Mapping) else {}
+    raw_n = mapped_data.get("n", input_data.get("n"))
+    if not isinstance(raw_n, int) or isinstance(raw_n, bool) or raw_n < 1:
+        raise ProofCertificateError(f"result row has invalid n: {raw_n!r}")
+    target = mapped_data.get("ineq", input_data.get("ineq"))
+    if not isinstance(target, str):
+        raise ProofCertificateError("result row has no string target inequality")
+    raw_conditions = mapped_data.get("conditions", input_data.get("conditions", []))
+    if not isinstance(raw_conditions, list) or not all(isinstance(item, str) for item in raw_conditions):
+        raise ProofCertificateError("result row conditions must be a list of strings")
+    raw_steps = run.get("expr_str")
+    if not isinstance(raw_steps, list):
+        raise ProofCertificateError("a proved result row must contain a list-valued run.expr_str")
+
+    terminal_residual: Optional[str] = None
+    trace = run.get("proof_trace")
+    if isinstance(trace, Mapping):
+        terminal = trace.get("terminal")
+        if isinstance(terminal, Mapping) and "residual" in terminal:
+            value = terminal.get("residual")
+            if not isinstance(value, str):
+                raise ProofCertificateError("proof_trace terminal residual must be a string")
+            terminal_residual = value
+
+    return verify_certificate(
+        raw_n,
+        target,
+        raw_conditions,
+        raw_steps,
+        terminal_residual=terminal_residual,
+    )
+
+
+def verify_jsonl(path: Path) -> Tuple[int, int, int, int]:
+    """Return (valid, invalid, error, skipped_unproved) counts for a v12 file."""
+    valid = invalid = errors = skipped = 0
+    with path.open("r", encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, start=1):
+            if not line.strip():
+                continue
+            try:
+                row = json.loads(line)
+                run = row.get("run") if isinstance(row, dict) else None
+                if isinstance(run, dict) and run.get("proved") is not True:
+                    skipped += 1
+                    continue
+                result = verify_result_row(row)
+            except (json.JSONDecodeError, ProofCertificateError) as exc:
+                errors += 1
+                print(f"line {line_number}: error: {exc}", file=sys.stderr)
+                continue
+            if result.valid:
+                valid += 1
+            else:
+                invalid += 1
+                print(f"line {line_number}: invalid: {result.reason}", file=sys.stderr)
+    return valid, invalid, errors, skipped
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="Verify v12 symbolic proof certificates exactly.")
+    parser.add_argument("result_file", type=Path, help="v12 JSONL result file (read-only)")
+    args = parser.parse_args(argv)
+    if not args.result_file.is_file():
+        parser.error(f"not a file: {args.result_file}")
+    valid, invalid, errors, skipped = verify_jsonl(args.result_file)
+    print(f"valid: {valid}")
+    print(f"invalid: {invalid}")
+    print(f"error: {errors}")
+    print(f"skipped_unproved: {skipped}")
+    return 0 if invalid == 0 and errors == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mce220_runner/data/entropy_vector_converter.py

@@ -0,0 +1,250 @@
+"""
+Entropy Inequality Vector-String Converter
+
+Converts between entropy inequality vector representation and compact string format.
+Vector format: (H(X_1)'s coefficient, H(X_2)'s coefficient, H(X_{1,2})'s coefficient, ...)
+String format: "3H(X_{1,2})" or "H(X_{1}) - 2H(X_{2,3})" (compact, no spaces, subscript notation)
+"""
+
+import numpy as np
+from scipy.sparse import csr_matrix
+import re
+
+
+def vector_to_string(vec) -> str:
+    """
+    Convert entropy inequality vector to compact string format.
+    
+    Format: "3H(X_{1,2})" or "H(X_{1}) - 2H(X_{2,3})" (no spaces, subscript notation)
+    
+    Args:
+        vec: Vector (numpy array, list, or csr_matrix) of length 2^n - 1
+        
+    Returns:
+        String like "3H(X_{1,2})" or "H(X_{1}) - 2H(X_{2,3})"
+        
+    Example:
+        >>> vector_to_string([0, 0, 3, 0])
+        '3H(X_{1,2})'
+        >>> vector_to_string([1, -2, 0, 0])
+        'H(X_{1}) - 2H(X_{2})'
+    """
+    # Convert to dense array
+    if isinstance(vec, csr_matrix):
+        vec_dense = vec.toarray().flatten()
+    else:
+        vec_dense = np.array(vec).flatten()
+    
+    # Estimate n from vector length: M = 2^n - 1
+    n = int(np.log2(len(vec_dense) + 1))
+    
+    terms = []
+    for i, coeff in enumerate(vec_dense):
+        if abs(coeff) > 1e-6:
+            # Convert index to subset representation
+            subset_idx = i + 1
+            # Convert to binary (low bit first)
+            subset_binary = [(subset_idx >> j) & 1 for j in range(n)]
+            
+            # Build subset string in format X_{1,2,3}
+            vars_list = [f"{j+1}" for j, b in enumerate(subset_binary) if b == 1]
+            if not vars_list:
+                continue  # Skip empty set
+            
+            subset_str = ",".join(vars_list)
+            
+            # Format coefficient and entropy term
+            if abs(coeff - 1.0) < 1e-6:
+                # Coefficient is 1
+                if coeff < 0:
+                    terms.append(f"-H(X_{{{subset_str}}})")
+                else:
+                    terms.append(f"H(X_{{{subset_str}}})")
+            elif abs(coeff + 1.0) < 1e-6:
+                # Coefficient is -1
+                terms.append(f"-H(X_{{{subset_str}}})")
+            else:
+                # Other coefficients
+                coeff_int = int(round(coeff))
+                if abs(coeff - coeff_int) < 1e-6:
+                    # Integer coefficient
+                    if coeff < 0:
+                        terms.append(f"-{abs(coeff_int)}H(X_{{{subset_str}}})")
+                    else:
+                        terms.append(f"{coeff_int}H(X_{{{subset_str}}})")
+                else:
+                    # Non-integer coefficient
+                    if coeff < 0:
+                        terms.append(f"-{abs(coeff)}H(X_{{{subset_str}}})")
+                    else:
+                        terms.append(f"{coeff}H(X_{{{subset_str}}})")
+    
+    if not terms:
+        return "0"
+    
+    # Join terms: positive terms with "+", negative terms already have "-"
+    result = terms[0]
+    for term in terms[1:]:
+        if term.startswith('-'):
+            result += term  # Already has "-"
+        else:
+            result += "+" + term
+    
+    return result
+
+
+def string_to_vector(ineq_str: str, n_variables: int = None) -> csr_matrix:
+    """
+    Convert entropy inequality string to vector representation.
+    
+    Parses strings like "3H(X_{1,2})" or "H(X_{1}) - 2H(X_{2,3})"
+    and converts to CSR sparse matrix of length 2^n - 1.
+    
+    Args:
+        ineq_str: String like "3H(X_{1,2})" or "H(X_{1}) - 2H(X_{2,3})"
+        n_variables: Number of variables (if None, inferred from string)
+        
+    Returns:
+        CSR sparse matrix (1 x (2^n - 1)) representing the inequality vector
+        
+     Example:
+            >>> string_to_vector("3H(X_{1,2})").toarray()
+            array([[0., 0., 3.]])
+            >>> string_to_vector("H(X_{1})-2H(X_{2})").toarray()
+            array([[ 1., -2.,  0.]])
+    """
+    # Remove spaces for easier parsing
+    ineq_str_clean = ineq_str.replace(' ', '')
+    
+    # Pattern to match: optional sign at start of term, optional coefficient, H(X_{...})
+    # This pattern handles: "3H(X_{1,2})", "-H(X_{1})", "H(X_{1,2,3})", "-2H(X_{1,2})"
+    # Also handles cases like "+3H" or "-2H"
+    pattern = r'([+-]?)(\d*\.?\d*)H\(X_\{([^}]+)\}\)'
+    
+    matches = re.findall(pattern, ineq_str_clean)
+    
+    if not matches:
+        # Try to parse "0" or empty string
+        if ineq_str.strip() == "0" or not ineq_str.strip():
+            # Need n_variables to create zero vector
+            if n_variables is None:
+                raise ValueError("Cannot infer n_variables from '0'. Please specify n_variables.")
+            return csr_matrix((1, 2**n_variables - 1), dtype=np.float64)
+        else:
+            raise ValueError(f"Could not parse inequality string: {ineq_str}")
+    
+    # Infer n_variables from the largest variable index found
+    max_var = 0
+    for sign, coeff, subset_str in matches:
+        vars_list = [int(x.strip()) for x in subset_str.split(',') if x.strip()]
+        if vars_list:
+            max_var = max(max_var, max(vars_list))
+    
+    if n_variables is None:
+        n_variables = max_var if max_var > 0 else 1
+    
+    # Create vector
+    M = 2**n_variables - 1
+    vec = np.zeros(M)
+    
+    for sign, coeff_str, subset_str in matches:
+        # Parse coefficient
+        if not coeff_str or coeff_str == '.':
+            coeff = 1.0
+        else:
+            coeff = float(coeff_str)
+        
+        # Apply sign
+        if sign == '-':
+            coeff = -coeff
+        
+        # Parse subset
+        vars_list = [int(x.strip()) for x in subset_str.split(',') if x.strip()]
+        
+        # Convert subset to index
+        # Index = sum(2^(i-1) for i in vars_list) - 1
+        subset_idx = 0
+        for var_idx in vars_list:
+            if 1 <= var_idx <= n_variables:
+                subset_idx += 2**(var_idx - 1)
+        
+        vec_idx = subset_idx - 1
+        
+        if 0 <= vec_idx < M:
+            vec[vec_idx] += coeff
+    
+    # Convert to CSR sparse matrix (1 x M)
+    return csr_matrix(vec, shape=(1, M), dtype=np.float64)
+
+
+# Example usage and test
+if __name__ == "__main__":
+    # Test vector_to_string
+    print("Testing vector_to_string:")
+    vec1 = np.array([0, 0, 3, 0])
+    str1 = vector_to_string(vec1)
+    print(f"  Vector {vec1} -> '{str1}'")
+    # Expected: "3H(X_{1,2})"
+
+    vec2 = np.array([1, -2, 0, 0])
+    str2 = vector_to_string(vec2)
+    print(f"  Vector {vec2} -> '{str2}'")
+    # Expected: "H(X_{1}) - 2H(X_{2})"
+
+    vec3 = np.array([0, 0, 0, 1, 0, 0, -1])
+    str3 = vector_to_string(vec3)
+    print(f"  Vector {vec3} -> '{str3}'")
+    # Expected: "H(X_{3}) - H(X_{1,2,3})" (for n=3)
+
+    print("\nTesting string_to_vector:")
+    # Test string_to_vector
+    str_test1 = "3H(X_{1,2})"
+    vec_back1 = string_to_vector(str_test1)
+    print(f"  String '{str_test1}' -> CSR Matrix")
+    print(f"    Type: {type(vec_back1)}")
+    print(f"    Shape: {vec_back1.shape}")
+    print(f"    Dense: {vec_back1.toarray().flatten()}")
+    print(f"    Non-zero elements: {vec_back1.nnz}")
+
+    str_test2 = "H(X_{1}) - 2H(X_{2})"
+    vec_back2 = string_to_vector(str_test2)
+    print(f"\n  String '{str_test2}' -> CSR Matrix")
+    print(f"    Type: {type(vec_back2)}")
+    print(f"    Shape: {vec_back2.shape}")
+    print(f"    Dense: {vec_back2.toarray().flatten()}")
+    print(f"    Non-zero elements: {vec_back2.nnz}")
+
+    str_test3 = "H(X_{1})-2H(X_{2})"  # No spaces version
+    vec_back3 = string_to_vector(str_test3)
+    print(f"\n  String '{str_test3}' -> CSR Matrix")
+    print(f"    Dense: {vec_back3.toarray().flatten()}")
+
+    print("\nRound-trip test:")
+    # Round-trip test - use proper length vector (for n=2, length should be 3)
+    original_vec = np.array([0, 0, 3])  # n=2: [H(X1), H(X2), H(X1,X2)]
+    str_repr = vector_to_string(original_vec)
+    recovered_vec = string_to_vector(str_repr)
+    print(f"  Original: {original_vec}")
+    print(f"  String: '{str_repr}'")
+    print(f"  Recovered (CSR): {recovered_vec.toarray().flatten()}")
+    print(f"  Match: {np.allclose(original_vec, recovered_vec.toarray().flatten())}")
+
+    # Another round-trip test with n=2
+    original_vec2 = np.array([1, -2, 0])
+    str_repr2 = vector_to_string(original_vec2)
+    recovered_vec2 = string_to_vector(str_repr2)
+    print(f"\n  Original: {original_vec2}")
+    print(f"  String: '{str_repr2}'")
+    print(f"  Recovered (CSR): {recovered_vec2.toarray().flatten()}")
+    print(f"  Match: {np.allclose(original_vec2, recovered_vec2.toarray().flatten())}")
+
+    # Test CSR round-trip
+    print("\nCSR round-trip test:")
+    original_csr = csr_matrix([1, -2, 3])
+    str_repr_csr = vector_to_string(original_csr)
+    recovered_csr = string_to_vector(str_repr_csr)
+    print(f"  Original CSR: {original_csr.toarray().flatten()}")
+    print(f"  String: '{str_repr_csr}'")
+    print(f"  Recovered CSR: {recovered_csr.toarray().flatten()}")
+    print(f"  Match: {np.allclose(original_csr.toarray().flatten(), recovered_csr.toarray().flatten())}")
+    print(f"  Both are CSR: {isinstance(original_csr, csr_matrix) and isinstance(recovered_csr, csr_matrix)}")

mce220_runner/dataset/README.md

@@ -0,0 +1,89 @@
+---
+pretty_name: Multi-Construction Entropy-Proof Benchmark (MCE-220)
+language:
+- en
+size_categories:
+- n<1K
+tags:
+- benchmark
+- information-theory
+- entropy
+- automated-theorem-proving
+- synthetic
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: data/questions.jsonl
+---
+
+# Multi-Construction Entropy-Proof Benchmark (MCE-220)
+
+MCE-220 is a frozen benchmark of 220 synthetic Shannon-type entropy-inequality proof problems. It spans 10 through 20 random variables with 20 questions at every value of `n`.
+
+The benchmark is balanced across five construction families. At every `n`, it contains four questions from each family:
+
+- weighted modular / hypergraphical constructions;
+- finite-field linearly representable constructions over GF(61);
+- directed-acyclic-graph constructions;
+- deterministic finite-field functional constructions; and
+- finite abelian 2-group quotient constructions.
+
+It is also divided evenly into 110 condition-required questions and 110 Shannon-only questions. The benchmark is intended for evaluating automated entropy-inequality provers, proof-search systems, and exact symbolic verification pipelines.
+
+## Dataset structure
+
+The Hub dataset exposes one `test` split from `data/questions.jsonl`. Each of its 220 records has:
+
+- `id`: stable benchmark identifier;
+- `n`: number of random variables;
+- `ineq`: target entropy expression, interpreted as `ineq >= 0`;
+- `conditions`: supplied equality conditions, represented as paired one-sided inequalities; and
+- `sha256`: digest of the canonical semantic question representation.
+
+The files under `audit/` are reproducibility evidence and are intentionally excluded from the dataset split:
+
+- `provenance.jsonl`: construction witness, planted certificate, tokenization, seeds, and structural metadata for every question;
+- `generation-report.jsonl`: per-cell generation and rejection accounting;
+- `run-manifest.json`: frozen configuration, dependency hashes, tokenizer identity, output hashes, and completion summary;
+- `validation-report.json`: exact certificate and artifact-integrity audit; and
+- `diversity-audit.json`: balance, uniqueness, and structural-diversity audit.
+
+The generation configuration is preserved as `generation/e2n_v2.toml`.
+
+## Generation and tokenization
+
+MCE-220 was generated from a preregistered grid of 11 values of `n`, five construction families, and four proof recipes. Each selected problem retains a planted exact certificate and a construction witness. Token counts use the fast tokenizer for `Qwen/Qwen3-0.6B` at commit `c1899de289a04d12100db370d81485cdf75e47ca`, without special tokens.
+
+The five construction families provide complementary entropic witnesses: modular component coverage, finite-field matrix ranks, rational Bayesian networks, deterministic polynomial transformations, and quotient profiles of finite abelian groups.
+
+## Validation and integrity
+
+The frozen package contains 220 unique question records and 220 matching provenance records. All selected certificates pass exact sparse rational verification. The validation report records zero errors, and the diversity audit passes all declared balance and uniqueness checks.
+
+Primary artifact SHA-256 values:
+
+- `questions.jsonl`: `1ff45298389fa9a0cc6000b833302d610c489334c88d40a07b28b45ea76c762a`
+- `provenance.jsonl`: `cbd708a699899127a254d7367df6f129fcc6eec73b50f05db86f01b5a732e189`
+- `generation-report.jsonl`: `50304ef59e263296d675bf63f79ceb04857deaba339bf7b491dca5d0752ca12c`
+
+## Intended use and limitations
+
+MCE-220 is an evaluation benchmark, not a training corpus or a representative sample of every entropy inequality. Its questions are synthetic and constructed to have planted Shannon-type certificates. The controlled sparse construction does not establish performance on arbitrary dense inequalities or non-Shannon inequalities. Planted certificate length is not necessarily the minimum proof length, because a question may admit other valid proofs.
+
+The benchmark supplies equality conditions because the evaluated AITIP workflow supports equality premises. Results should retain question-level accounting, exact proof verification, and resource or timeout settings.
+
+## Citation
+
+The associated manuscript is forthcoming/unpublished:
+
+```bibtex
+@unpublished{wong2026automated,
+  title  = {Automated Proving of Shannon-Type Entropy Inequalities via Fine-Tuned Language Models and Guided Tree Search},
+  author = {Wong, Shing Yin and Liu, Shaocheng and Song, Linqi and Gohari, Amin and Li, Cheuk Ting},
+  year   = {2026},
+  note   = {Manuscript in preparation}
+}
+```
+
+No reuse license has been assigned to this private release.

mce220_runner/dataset/audit/diversity-audit.json

@@ -0,0 +1,422 @@
+{
+  "counts": {
+    "by_method_n": {
+      "abelian_product_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "dag_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "functional_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "linear_rank_gf61_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "weighted_modular_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      }
+    },
+    "by_n": {
+      "10": 20,
+      "11": 20,
+      "12": 20,
+      "13": 20,
+      "14": 20,
+      "15": 20,
+      "16": 20,
+      "17": 20,
+      "18": 20,
+      "19": 20,
+      "20": 20
+    },
+    "by_residual_mode": {
+      "condition": 110,
+      "shannon": 110
+    },
+    "by_variant_method_n": {
+      "abelian_product_v2": {
+        "10": {
+          "abelian_product_v2": 4
+        },
+        "11": {
+          "abelian_product_v2": 4
+        },
+        "12": {
+          "abelian_product_v2": 4
+        },
+        "13": {
+          "abelian_product_v2": 4
+        },
+        "14": {
+          "abelian_product_v2": 4
+        },
+        "15": {
+          "abelian_product_v2": 4
+        },
+        "16": {
+          "abelian_product_v2": 4
+        },
+        "17": {
+          "abelian_product_v2": 4
+        },
+        "18": {
+          "abelian_product_v2": 4
+        },
+        "19": {
+          "abelian_product_v2": 4
+        },
+        "20": {
+          "abelian_product_v2": 4
+        }
+      },
+      "dag_v2": {
+        "10": {
+          "dag_v2": 4
+        },
+        "11": {
+          "dag_v2": 4
+        },
+        "12": {
+          "dag_v2": 4
+        },
+        "13": {
+          "dag_v2": 4
+        },
+        "14": {
+          "dag_v2": 4
+        },
+        "15": {
+          "dag_v2": 4
+        },
+        "16": {
+          "dag_v2": 4
+        },
+        "17": {
+          "dag_v2": 4
+        },
+        "18": {
+          "dag_v2": 4
+        },
+        "19": {
+          "dag_v2": 4
+        },
+        "20": {
+          "dag_v2": 4
+        }
+      },
+      "functional_v2": {
+        "10": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "11": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "12": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "13": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "14": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "15": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "16": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "17": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "18": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "19": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        },
+        "20": {
+          "linear": 1,
+          "mixed": 2,
+          "nonlinear": 1
+        }
+      },
+      "linear_rank_gf61_v2": {
+        "10": {
+          "linear_rank_gf61_v2": 4
+        },
+        "11": {
+          "linear_rank_gf61_v2": 4
+        },
+        "12": {
+          "linear_rank_gf61_v2": 4
+        },
+        "13": {
+          "linear_rank_gf61_v2": 4
+        },
+        "14": {
+          "linear_rank_gf61_v2": 4
+        },
+        "15": {
+          "linear_rank_gf61_v2": 4
+        },
+        "16": {
+          "linear_rank_gf61_v2": 4
+        },
+        "17": {
+          "linear_rank_gf61_v2": 4
+        },
+        "18": {
+          "linear_rank_gf61_v2": 4
+        },
+        "19": {
+          "linear_rank_gf61_v2": 4
+        },
+        "20": {
+          "linear_rank_gf61_v2": 4
+        }
+      },
+      "weighted_modular_v2": {
+        "10": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "11": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "12": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "13": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "14": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "15": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "16": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "17": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "18": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "19": {
+          "shared": 2,
+          "weighted": 2
+        },
+        "20": {
+          "shared": 2,
+          "weighted": 2
+        }
+      }
+    },
+    "complete_cells": 220,
+    "generation_cells": 220,
+    "provenance": 220,
+    "questions": 220,
+    "structural_signature_count_by_method_n": {
+      "abelian_product_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "dag_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "functional_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "linear_rank_gf61_v2": {
+        "10": 4,
+        "11": 4,
+        "12": 4,
+        "13": 4,
+        "14": 4,
+        "15": 4,
+        "16": 4,
+        "17": 4,
+        "18": 4,
+        "19": 4,
+        "20": 4
+      },
+      "weighted_modular_v2": {
+        "10": 2,
+        "11": 2,
+        "12": 2,
+        "13": 2,
+        "14": 2,
+        "15": 2,
+        "16": 2,
+        "17": 2,
+        "18": 2,
+        "19": 2,
+        "20": 2
+      }
+    }
+  },
+  "error_count": 0,
+  "errors": [],
+  "expectations": {
+    "expected_per_method_n": 4,
+    "expected_per_n": 20,
+    "expected_total": 220,
+    "methods": [
+      "weighted_modular_v2",
+      "linear_rank_gf61_v2",
+      "dag_v2",
+      "functional_v2",
+      "abelian_product_v2"
+    ],
+    "n_values": [
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20
+    ],
+    "require_complete_cells": true,
+    "require_exact_uniqueness": true,
+    "residual_modes": [
+      "condition",
+      "shannon"
+    ]
+  },
+  "generation_report_rows": 220,
+  "pass": true,
+  "rejections": {
+    "by_reason": {
+      "token_window": 8
+    },
+    "total": 8
+  },
+  "schema_version": "reviewer-witness-diversity-audit-v1",
+  "uniqueness": {
+    "duplicate_condition_set_groups": [],
+    "duplicate_initial_target_groups": [],
+    "duplicate_selected_residual_groups": [],
+    "duplicate_witness_groups": [],
+    "unique_condition_sets": 220,
+    "unique_initial_targets": 220,
+    "unique_selected_residuals": 220,
+    "unique_witnesses": 220,
+    "witness_scope": "within each method and n"
+  }
+}

mce220_runner/dataset/audit/generation-report.jsonl

@@ -0,0 +1,220 @@
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3701457636437077952,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":10,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15246363881976218358,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":10,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3172063088685357728,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":10,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5056663783486606013,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":10,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9539850679019901972,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":11,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7955716649502997116,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":11,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4812851374726980080,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":11,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4284913358355807734,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":11,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8708808592976883946,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":12,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14394515690009120654,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":12,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5074899767269115176,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":12,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":2,"benchmark":"e2n-witness-first-v2","cell_seed":8138142372704579071,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":12,"quota":1,"recipe_index":3,"rejected":{"token_window":1},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11237412930374853913,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":13,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2622604060345787656,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":13,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1297526053728799686,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":13,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":2,"benchmark":"e2n-witness-first-v2","cell_seed":12938408747832804044,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":13,"quota":1,"recipe_index":3,"rejected":{"token_window":1},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15148184769047820,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":14,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11212742246525318633,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":14,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9952603600299452875,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":14,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17684431903806972992,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":14,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4358867344586403829,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":15,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13909308547342205491,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":15,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15975291380394989210,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":15,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9716087254387917306,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":15,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17539831590544119906,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":16,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11853313365675990415,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":16,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10445827094562493869,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":16,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4702628459963138141,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":16,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6338436637880042951,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":17,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4623525552571304476,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":17,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8389339039156670354,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":17,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16353085863076184214,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":17,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2196169065690155443,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":18,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15059909006415722323,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":18,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14583201521060589027,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":18,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5612252589744170130,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":18,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2728962570584640889,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":19,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9758846155311160259,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":19,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2720845152774216335,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":19,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5121022496212244148,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":19,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16436906769862432774,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"weighted_modular_v2","n":20,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14831573543779349003,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"weighted_modular_v2","n":20,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4480046151243417079,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"weighted_modular_v2","n":20,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"weighted"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9903418647447938583,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"weighted_modular_v2","n":20,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"shared"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4936832681239338862,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":10,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15232824178863167110,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":10,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8186240528289594329,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":10,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17500194849731588113,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":10,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11832034070095118311,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":11,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8133750959736225035,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":11,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2273770823316088623,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":11,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1462948322211576970,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":11,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":18067028359118754372,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":12,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11705998351666552518,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":12,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16254702609706164343,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":12,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2968902127481300008,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":12,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5936000122885923694,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":13,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15604122199806785487,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":13,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9337414342802015969,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":13,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16923520896556911049,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":13,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1464669209368047966,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":14,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10174962824566969569,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":14,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12100853506115398562,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":14,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5228631607116939670,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":14,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6393201095674814746,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":15,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15285263391928485372,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":15,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":549978287588786307,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":15,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5273822472737093431,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":15,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17505444870217075492,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":16,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12065121403697794235,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":16,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15963481462025769689,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":16,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9888338464856776367,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":16,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11743591167866989887,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":17,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5407253042649969843,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":17,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5124340889268399352,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":17,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7866954243082797305,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":17,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7141475136732988801,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":18,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16881613849503902662,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":18,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10510564794829486452,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":18,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13637027472625371970,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":18,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10865444810274626052,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":19,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16407715404674462704,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":19,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2967182459071344429,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":19,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8842815126698378794,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":19,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16996992628039077843,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"linear_rank_gf61_v2","n":20,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11919690030700392770,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"linear_rank_gf61_v2","n":20,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2310562788219762726,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"linear_rank_gf61_v2","n":20,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2443067625292808296,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"linear_rank_gf61_v2","n":20,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3184567625312884139,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":10,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6822340930228026675,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":10,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11359352071557003676,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":10,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11260656603170133794,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":10,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17431958280368089774,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":11,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":95470021134927501,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":11,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":18173423042958114467,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":11,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10912102982755826622,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":11,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14647759189369950544,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":12,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17074290522542464048,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":12,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11051767266233656569,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":12,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1918497853187515936,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":12,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1907240975364747342,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":13,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17785309102802652106,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":13,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7181223247123743876,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":13,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2263938430705632913,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":13,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16433270489078283260,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":14,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15721389692426090446,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":14,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":2,"benchmark":"e2n-witness-first-v2","cell_seed":16971901269964792975,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":14,"quota":1,"recipe_index":2,"rejected":{"token_window":1},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17994565298475579634,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":14,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8007488871997086332,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":15,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3719582981595767999,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":15,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6989838346124019281,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":15,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2665890865320848013,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":15,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14437300812821433667,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":16,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6577469201406442179,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":16,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13041507654325523808,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":16,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3570771541096614982,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":16,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11815261720096583648,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":17,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16648488661857383898,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":17,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":3,"benchmark":"e2n-witness-first-v2","cell_seed":12258752852871151798,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":17,"quota":1,"recipe_index":2,"rejected":{"token_window":2},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6381643106495975100,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":17,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15423199845599069898,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":18,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13268465811212531448,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":18,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":2,"benchmark":"e2n-witness-first-v2","cell_seed":4070565829160279811,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":18,"quota":1,"recipe_index":2,"rejected":{"token_window":1},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":105930261327445421,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":18,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10109908015276543465,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":19,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4956562969327863550,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":19,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5008331369838333772,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":19,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17827741488378490065,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":19,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11552473092704060,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"dag_v2","n":20,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17278969316211330178,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"dag_v2","n":20,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5863619077421464638,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"dag_v2","n":20,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":3,"benchmark":"e2n-witness-first-v2","cell_seed":12216008678726813341,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"dag_v2","n":20,"quota":1,"recipe_index":3,"rejected":{"token_window":2},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12136638063071141276,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":10,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6986443780866752496,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":10,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3781574741278654854,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":10,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2343031434917169256,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":10,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":530243949934307503,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":11,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4147310449574325073,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":11,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13253479536535202397,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":11,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5481697251196607234,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":11,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3419907753431159668,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":12,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":18349149685442145724,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":12,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12471696088800926995,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":12,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5514582684015399052,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":12,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14479113219010784219,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":13,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7511176911362227743,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":13,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11305014799087235417,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":13,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10456612778851741111,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":13,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17198548155075593163,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":14,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12054220294986305355,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":14,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6317325096853017294,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":14,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5557861230106346201,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":14,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15256452385745187341,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":15,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4984913849055553761,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":15,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1922809319832171575,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":15,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7290953918310180562,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":15,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2207934633545694466,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":16,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8865819739701358330,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":16,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8060021619136953608,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":16,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16572719200988242280,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":16,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4170973570952992437,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":17,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12513124999520014137,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":17,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14786551003661347752,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":17,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7575961521772144425,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":17,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5161629846671816961,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":18,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4552954781211765265,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":18,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12954501444229679227,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":18,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3734117315160446273,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":18,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15062695363987721571,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":19,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12101175090757923717,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":19,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3575707971365674080,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":19,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5105430873146479519,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":19,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15318398621928381177,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"functional_v2","n":20,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"linear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13391810045493605038,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"functional_v2","n":20,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"nonlinear"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":16474088650880862895,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"functional_v2","n":20,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9697458621349092067,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"functional_v2","n":20,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":"mixed"}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14098164715461887531,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":10,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":7413113805965221460,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":10,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8118303950565053392,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":10,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1018118677028597230,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":10,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14973580586272694633,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":11,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1362989527561847042,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":11,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":14381275516087489947,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":11,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2369240884198343729,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":11,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":221228626003247890,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":12,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4312760315371342800,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":12,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15528857495560036646,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":12,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1186195495943774426,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":12,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10014313637976231552,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":13,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1552613301840816399,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":13,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":954177495762986129,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":13,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5525319345874424799,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":13,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":18027165872156795930,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":14,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":18098129184875256583,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":14,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13888201606725553085,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":14,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":919212854944883606,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":14,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8165437892884726391,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":15,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11934378534096084033,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":15,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":12133732172664841221,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":15,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5360334427668528317,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":15,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5030154206041038858,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":16,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11647864275748426632,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":16,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":4062663468625614856,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":16,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":18407997404765423429,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":16,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":13118711139945243757,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":17,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3758826947236076007,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":17,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":11246400704042830426,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":17,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":10213094060571213725,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":17,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":9084829840437732960,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":18,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":5453944936310748968,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":18,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8525833265372454032,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":18,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":2691777673477642656,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":18,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6285703479023902455,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":19,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":3138362092886322139,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":19,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1071160566897403333,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":19,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":17567046285549651617,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":19,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":6736118940594014540,"complete":true,"condition_width":8,"k":12,"m_eq":1,"method":"abelian_product_v2","n":20,"quota":1,"recipe_index":0,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":15176902604380923354,"complete":true,"condition_width":12,"k":16,"m_eq":1,"method":"abelian_product_v2","n":20,"quota":1,"recipe_index":1,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":8216170727549535292,"complete":true,"condition_width":8,"k":20,"m_eq":2,"method":"abelian_product_v2","n":20,"quota":1,"recipe_index":2,"rejected":{},"residual_mode":"condition","schema_version":"reviewer-benchmark-v1","witness_variant":null}
+{"accepted":1,"attempted":1,"benchmark":"e2n-witness-first-v2","cell_seed":1392148745951243703,"complete":true,"condition_width":8,"k":16,"m_eq":2,"method":"abelian_product_v2","n":20,"quota":1,"recipe_index":3,"rejected":{},"residual_mode":"shannon","schema_version":"reviewer-benchmark-v1","witness_variant":null}

mce220_runner/dataset/audit/run-manifest.json

@@ -0,0 +1 @@
+{"benchmark":"e2n-witness-first-v2","config":{"benchmark":{"coefficient_max":10,"max_attempts_per_cell":240,"name":"e2n-witness-first-v2","output_dir":"../outputs/e2n-v2","quota_per_cell":1,"require_complete":true,"require_unique_witness":true,"seed":20260825},"format":{"prompt_template":"TARGET:\n{target}>=0\n\nCONDITIONS:\n{conditions}\n\n"},"grid":{"methods":["weighted_modular_v2","linear_rank_gf61_v2","dag_v2","functional_v2","abelian_product_v2"],"n_values":[10,11,12,13,14,15,16,17,18,19,20],"recipes":[{"condition_width":8,"k":12,"m_eq":1,"residual_mode":"condition","witness_variants":{"functional_v2":"linear","weighted_modular_v2":"weighted"}},{"condition_width":12,"k":16,"m_eq":1,"residual_mode":"shannon","witness_variants":{"functional_v2":"nonlinear","weighted_modular_v2":"shared"}},{"condition_width":8,"k":20,"m_eq":2,"residual_mode":"condition","witness_variants":{"functional_v2":"mixed","weighted_modular_v2":"weighted"}},{"condition_width":8,"k":16,"m_eq":2,"residual_mode":"shannon","witness_variants":{"functional_v2":"mixed","weighted_modular_v2":"shared"}}]},"tokenization":{"counter":"huggingface","full_max":2200,"full_min":801,"hf_model":"Qwen/Qwen3-0.6B","hf_revision":"c1899de289a04d12100db370d81485cdf75e47ca","hf_use_fast":true,"target_max":799,"target_min":501}},"config_sha256":"1b1f298ed012071c85e9cfb286fe5dcf7c183383de92041754d8a7802f426421","generator_dependency_sha256":{"data/finite_field.py":"c9738c10a16ea2cfb3cde346a23673d1536dbfce491f8871346f441b9b4c2a6e","data/witness_first.py":"7af2a1d6096862a776e9c8530d0c6a3ae2b83aa7ecd8bb1026256d6f1cdc3560","data/witness_v2_algebraic.py":"ffbd48eb673a3f6f842327d00431285bbae8963a7e20f6956e37e544fa37165f","data/witness_v2_graph.py":"c81adcfefcf6ffc0e816f1b338af13323bc80e06293e8cac6b28a3b0ae2efc8a"},"generator_source_sha256":"7af2a1d6096862a776e9c8530d0c6a3ae2b83aa7ecd8bb1026256d6f1cdc3560","output_sha256":{"generation-report.jsonl":"50304ef59e263296d675bf63f79ceb04857deaba339bf7b491dca5d0752ca12c","provenance.jsonl":"cbd708a699899127a254d7367df6f129fcc6eec73b50f05db86f01b5a732e189","questions.jsonl":"1ff45298389fa9a0cc6000b833302d610c489334c88d40a07b28b45ea76c762a"},"schema_version":"reviewer-benchmark-v1","selector_source_sha256":"83a328168eac42cedd3412a9c8b5624b8683a52a14042b5defbccf6d833efefe","summary":{"benchmark":"e2n-witness-first-v2","cells":220,"complete":true,"complete_cells":220,"questions":220},"tokenizer":{"add_special_tokens":false,"is_fast":true,"kind":"huggingface","model":"Qwen/Qwen3-0.6B","requested_revision":"c1899de289a04d12100db370d81485cdf75e47ca","resolved_commit":"c1899de289a04d12100db370d81485cdf75e47ca","tokenizer_class":"Qwen2TokenizerFast","transformers_version":"4.55.2","trust_remote_code":true,"use_fast":true}}

mce220_runner/dataset/audit/validation-report.json

@@ -0,0 +1 @@
+{"benchmark":"e2n-witness-first-v2","benchmark_dir":"C:\\Users\\user\\Documents\\ChatGPT\\Entropy Inequality\\experiments\\reviewer_response\\outputs\\e2n-v2","counts":{"artifact_hashes_checked":3,"certificates_verified":220,"errors":0,"provenance_rows":220,"question_rows":220,"rows_checked":220},"errors":[],"schema_version":"reviewer-generated-benchmark-audit-v1","valid":true}

mce220_runner/dataset/generation/e2n_v2.toml

@@ -0,0 +1,63 @@
+[benchmark]
+name = "e2n-witness-first-v2"
+seed = 20260825
+output_dir = "../outputs/e2n-v2"
+quota_per_cell = 1
+max_attempts_per_cell = 240
+coefficient_max = 10
+require_complete = true
+require_unique_witness = true
+
+[grid]
+methods = [
+  "weighted_modular_v2",
+  "linear_rank_gf61_v2",
+  "dag_v2",
+  "functional_v2",
+  "abelian_product_v2",
+]
+n_values = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+
+# Four questions per construction family and n.  The model sees equality
+# conditions only.  "condition" means at least one equality action remains in
+# the selected proof-completion state; "shannon" means none remains.
+[[grid.recipes]]
+k = 12
+m_eq = 1
+condition_width = 8
+residual_mode = "condition"
+witness_variants = { weighted_modular_v2 = "weighted", functional_v2 = "linear" }
+
+[[grid.recipes]]
+k = 16
+m_eq = 1
+condition_width = 12
+residual_mode = "shannon"
+witness_variants = { weighted_modular_v2 = "shared", functional_v2 = "nonlinear" }
+
+[[grid.recipes]]
+k = 20
+m_eq = 2
+condition_width = 8
+residual_mode = "condition"
+witness_variants = { weighted_modular_v2 = "weighted", functional_v2 = "mixed" }
+
+[[grid.recipes]]
+k = 16
+m_eq = 2
+condition_width = 8
+residual_mode = "shannon"
+witness_variants = { weighted_modular_v2 = "shared", functional_v2 = "mixed" }
+
+[tokenization]
+counter = "huggingface"
+hf_model = "Qwen/Qwen3-0.6B"
+hf_revision = "c1899de289a04d12100db370d81485cdf75e47ca"
+hf_use_fast = true
+target_min = 501
+target_max = 799
+full_min = 801
+full_max = 2200
+
+[format]
+prompt_template = "TARGET:\n{target}>=0\n\nCONDITIONS:\n{conditions}\n\n"

mce220_runner/download_assets.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""Download and verify the pinned MCE-220 inference assets."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+
+BUNDLE_DIR = Path(__file__).resolve().parent
+DATASET_REPO = 'entropyinequalityprover/MCE-220'
+DATASET_REVISION = '5650d7c8198a68116e8d12934aed41a37866ba92'
+MODEL_REPO = 'entropyinequalityprover/models_and_scripts'
+MODEL_REVISION = '7fcfe778e1c36cd67e88ea8aa2ee761a50a39127'
+BASE_MODEL_REPO = 'Qwen/Qwen3-0.6B'
+BASE_MODEL_REVISION = 'c1899de289a04d12100db370d81485cdf75e47ca'
+CHECKPOINT_PREFIX = 'qwen-06b-sft-4type-old-format-lora-dataset-a-4096-balanced-higher-maxm/checkpoint-9534'
+
+DATASET_SHA256 = {
+    "README.md": "909828a43ace9c3d4e9aa2e2fe96812dadd1c08ece52c87cf4dc896ad4ce0452",
+    "audit/diversity-audit.json": "56721eb34f35fa9acc2d81bbb13b0ea263a7f29bc8838372339dbc38ecda44a4",
+    "audit/generation-report.jsonl": "50304ef59e263296d675bf63f79ceb04857deaba339bf7b491dca5d0752ca12c",
+    "audit/provenance.jsonl": "cbd708a699899127a254d7367df6f129fcc6eec73b50f05db86f01b5a732e189",
+    "audit/run-manifest.json": "ac32fdaecf845714f9802c584c91b8743398898ff7e7c1f36c43014dea36d9a6",
+    "audit/validation-report.json": "3f86d1391c15a343cb938092a456ce2b5b88bb7f1ebcbf4089d0c8174c7e4d3c",
+    "data/questions.jsonl": "1ff45298389fa9a0cc6000b833302d610c489334c88d40a07b28b45ea76c762a",
+    "generation/e2n_v2.toml": "3346eb6fc6aa0bb70ca15f9a840d7b0f366418072c58cb76d32e0f8ac9faae4a"
+}
+CHECKPOINT_FILES = (
+    "adapter_config.json",
+    "adapter_model.safetensors",
+    "added_tokens.json",
+    "chat_template.jinja",
+    "merges.txt",
+    "special_tokens_map.json",
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "vocab.json",
+)
+CHECKPOINT_CRITICAL_SHA256 = {
+    "adapter_model.safetensors": "813507e95124a06a4f8dc69d641b7fbcde791b4ec7d610f7c9403709588deb56",
+    "tokenizer.json": "aeb13307a71acd8fe81861d94ad54ab689df773318809eed3cbe794b4492dae4",
+}
+EXCLUDED_CHECKPOINT_FILES = (
+    "optimizer.pt",
+    "scheduler.pt",
+    "trainer_state.json",
+    "training_args.bin",
+)
+EXCLUDED_CHECKPOINT_PREFIXES = ("rng_state_",)
+BASE_MODEL_FILES = (
+    "config.json",
+    "generation_config.json",
+    "merges.txt",
+    "model.safetensors",
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "vocab.json",
+)
+BASE_MODEL_CRITICAL_SHA256 = {
+    "model.safetensors": "f47f71177f32bcd101b7573ec9171e6a57f4f4d31148d38e382306f42996874b",
+    "tokenizer.json": "aeb13307a71acd8fe81861d94ad54ab689df773318809eed3cbe794b4492dae4",
+}
+
+
+class AssetError(RuntimeError):
+    pass
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def visible_files(root: Path) -> set[str]:
+    if not root.is_dir():
+        return set()
+    return {
+        path.relative_to(root).as_posix()
+        for path in root.rglob("*")
+        if path.is_file() and ".cache" not in path.relative_to(root).parts
+    }
+
+
+def require_hashes(root: Path, expected: dict[str, str]) -> None:
+    for relative, wanted in expected.items():
+        path = root / relative
+        if not path.is_file():
+            raise AssetError(f"missing required file: {path}")
+        actual = sha256_file(path)
+        if actual != wanted:
+            raise AssetError(
+                f"SHA-256 mismatch for {path}: expected {wanted}, got {actual}"
+            )
+
+
+def verify_dataset_tree(root: Path) -> None:
+    expected_files = set(DATASET_SHA256)
+    actual_files = visible_files(root)
+    if actual_files != expected_files:
+        raise AssetError(
+            "dataset file set mismatch: missing="
+            f"{sorted(expected_files - actual_files)}, extra="
+            f"{sorted(actual_files - expected_files)}"
+        )
+    require_hashes(root, DATASET_SHA256)
+    question_path = root / "data/questions.jsonl"
+    rows = [
+        json.loads(line)
+        for line in question_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    if len(rows) != 220 or len({row.get("id") for row in rows}) != 220:
+        raise AssetError("questions.jsonl must contain 220 unique question IDs")
+    if any(
+        set(row) != {"id", "n", "ineq", "conditions", "sha256"}
+        for row in rows
+    ):
+        raise AssetError("questions.jsonl has an unexpected schema")
+
+
+def verify_checkpoint(root: Path) -> None:
+    expected = set(CHECKPOINT_FILES)
+    actual = visible_files(root)
+    if actual != expected:
+        raise AssetError(
+            "checkpoint file set mismatch: missing="
+            f"{sorted(expected - actual)}, extra={sorted(actual - expected)}"
+        )
+    for path in actual:
+        name = Path(path).name
+        if name in EXCLUDED_CHECKPOINT_FILES or any(
+            name.startswith(prefix) for prefix in EXCLUDED_CHECKPOINT_PREFIXES
+        ):
+            raise AssetError(f"training-only checkpoint file present: {path}")
+    require_hashes(root, CHECKPOINT_CRITICAL_SHA256)
+
+
+def verify_base_model(root: Path) -> None:
+    expected = set(BASE_MODEL_FILES)
+    actual = visible_files(root)
+    if actual != expected:
+        raise AssetError(
+            "base-model file set mismatch: missing="
+            f"{sorted(expected - actual)}, extra={sorted(actual - expected)}"
+        )
+    require_hashes(root, BASE_MODEL_CRITICAL_SHA256)
+
+
+def download_assets(asset_dir: Path) -> None:
+    asset_dir.mkdir(parents=True, exist_ok=True)
+    snapshot_download(
+        repo_id=DATASET_REPO,
+        repo_type="dataset",
+        revision=DATASET_REVISION,
+        allow_patterns=list(DATASET_SHA256),
+        local_dir=asset_dir / "dataset-source",
+        local_dir_use_symlinks=False,
+    )
+    snapshot_download(
+        repo_id=MODEL_REPO,
+        repo_type="model",
+        revision=MODEL_REVISION,
+        allow_patterns=[f"{CHECKPOINT_PREFIX}/{name}" for name in CHECKPOINT_FILES],
+        local_dir=asset_dir / "model-repo",
+        local_dir_use_symlinks=False,
+    )
+    snapshot_download(
+        repo_id=BASE_MODEL_REPO,
+        repo_type="model",
+        revision=BASE_MODEL_REVISION,
+        allow_patterns=list(BASE_MODEL_FILES),
+        local_dir=asset_dir / "qwen3-0.6b",
+        local_dir_use_symlinks=False,
+    )
+
+
+def verify_all(asset_dir: Path) -> dict[str, object]:
+    bundled_dataset = BUNDLE_DIR / "dataset"
+    downloaded_dataset = asset_dir / "dataset-source"
+    checkpoint = asset_dir / "model-repo" / CHECKPOINT_PREFIX
+    base_model = asset_dir / "qwen3-0.6b"
+    verify_dataset_tree(bundled_dataset)
+    verify_dataset_tree(downloaded_dataset)
+    for relative in DATASET_SHA256:
+        if (
+            (bundled_dataset / relative).read_bytes()
+            != (downloaded_dataset / relative).read_bytes()
+        ):
+            raise AssetError(f"bundled dataset differs from pinned source: {relative}")
+    verify_checkpoint(checkpoint)
+    verify_base_model(base_model)
+    return {
+        "status": "verified",
+        "dataset": {
+            "repo": DATASET_REPO,
+            "revision": DATASET_REVISION,
+            "rows": 220,
+        },
+        "checkpoint": {
+            "repo": MODEL_REPO,
+            "revision": MODEL_REVISION,
+            "path": str(checkpoint),
+        },
+        "base_model": {
+            "repo": BASE_MODEL_REPO,
+            "revision": BASE_MODEL_REVISION,
+            "path": str(base_model),
+        },
+    }
+
+
+def parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument(
+        "--asset-dir",
+        type=Path,
+        default=BUNDLE_DIR / "assets",
+        help="Asset directory (default: mce220_runner/assets).",
+    )
+    ap.add_argument(
+        "--verify-only",
+        action="store_true",
+        help="Do not access the network; verify already downloaded assets.",
+    )
+    return ap
+
+
+def main() -> int:
+    args = parser().parse_args()
+    asset_dir = args.asset_dir.expanduser().resolve()
+    try:
+        if not args.verify_only:
+            download_assets(asset_dir)
+        print(json.dumps(verify_all(asset_dir), indent=2, sort_keys=True))
+        return 0
+    except AssetError as exc:
+        print(f"asset verification failed: {exc}", file=__import__("sys").stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mce220_runner/experiments/reviewer_response/configs/inference_policy.toml

@@ -0,0 +1,16 @@
+# Frozen policy for all new reviewer proposed-model inference (E2-N, E6,
+# E9-A/E9-B and E10). E2-R is a retrospective audit of the submitted run and
+# is intentionally not governed by this new policy.
+
+[policy]
+schema_version = "reviewer-inference-policy-v1"
+sample_max_time_sec = 1000
+sample_max_tree_size = 6000
+sample_max_llm_calls = 0 # No separate call cap; time and tree limits still apply.
+
+[enforcement]
+time = "cooperative_soft"
+tree = "cooperative_soft"
+hard_wall_time_enforced = false
+external_hard_timeout_required = true
+note = "The runner checks budgets between search operations; already submitted model generations may finish after a budget is reached."

mce220_runner/experiments/reviewer_response/run_search_benchmark.py

@@ -0,0 +1,1108 @@
+"""Reproducible wrapper for the submitted proposed-model search pipeline.
+
+The wrapper deliberately does not import or modify the search runner.  It
+freezes the submitted search settings, records a machine-readable manifest,
+executes the tracked runner as a child process, and verifies successful proof
+artifacts with the standalone exact verifier.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import importlib.metadata
+import json
+import os
+import platform
+import shlex
+import subprocess
+import sys
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Sequence
+
+
+# Direct execution sets sys.path[0] to experiments/reviewer_response rather
+# than the repository root. Add the root explicitly so resume verification can
+# import beam_search_model2 in the same way as ``python -m`` execution.
+_REPO_ROOT_FOR_IMPORTS = Path(__file__).resolve().parents[2]
+if str(_REPO_ROOT_FOR_IMPORTS) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT_FOR_IMPORTS))
+
+
+SCHEMA_VERSION = "reviewer-search-run-v4"
+EXECUTION_CONFIG_SCHEMA_VERSION = "e2n-execution-config-v1"
+RESOURCE_POLICY_VERSION = "reviewer-inference-policy-v1"
+SAMPLE_MAX_TIME_SEC = 1000.0
+SAMPLE_MAX_TREE_SIZE = 6000
+DEFAULT_RUNNER = Path("beam_search_model2/run_on_window_shear_jsonl_v12.py")
+DEFAULT_GPU_IDS = "4,4,5,5,6,6,7,7"
+PACKAGE_NAMES = (
+    "accelerate",
+    "numpy",
+    "peft",
+    "scipy",
+    "sympy",
+    "torch",
+    "transformers",
+)
+RELEVANT_INHERITED_ENV = (
+    "CUDA_VISIBLE_DEVICES",
+    "HF_HOME",
+    "HF_HUB_OFFLINE",
+    "MKL_NUM_THREADS",
+    "OMP_NUM_THREADS",
+    "OPENBLAS_NUM_THREADS",
+    "PYTHONHASHSEED",
+    "TOKENIZERS_PARALLELISM",
+    "TRANSFORMERS_CACHE",
+)
+
+
+class LauncherError(ValueError):
+    """Raised for a launcher preflight or artifact error."""
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _file_artifact(path: Path) -> dict[str, Any]:
+    return {
+        "path": str(path),
+        "bytes": path.stat().st_size,
+        "sha256": _sha256_file(path),
+    }
+
+
+def _checkpoint_artifact(path: Path) -> dict[str, Any]:
+    """Hash a checkpoint file or a checkpoint directory deterministically."""
+
+    if path.is_file():
+        return {"kind": "file", **_file_artifact(path)}
+    if not path.is_dir():
+        raise LauncherError(f"checkpoint does not exist: {path}")
+
+    files: dict[str, dict[str, Any]] = {}
+    tree_digest = hashlib.sha256()
+    total_bytes = 0
+    for child in sorted((item for item in path.rglob("*") if item.is_file())):
+        relative = child.relative_to(path).as_posix()
+        size = child.stat().st_size
+        sha256 = _sha256_file(child)
+        files[relative] = {"bytes": size, "sha256": sha256}
+        total_bytes += size
+        tree_digest.update(relative.encode("utf-8"))
+        tree_digest.update(b"\0")
+        tree_digest.update(sha256.encode("ascii"))
+        tree_digest.update(b"\0")
+        tree_digest.update(str(size).encode("ascii"))
+        tree_digest.update(b"\n")
+    if not files:
+        raise LauncherError(f"checkpoint directory contains no files: {path}")
+    return {
+        "kind": "directory",
+        "path": str(path),
+        "file_count": len(files),
+        "bytes": total_bytes,
+        "sha256": tree_digest.hexdigest(),
+        "files": files,
+    }
+
+
+def _question_profile(path: Path) -> dict[str, Any]:
+    count = 0
+    ids = 0
+    variable_counts: list[int] = []
+    extra_fields: set[str] = set()
+    with path.open("r", encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, start=1):
+            if not line.strip():
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise LauncherError(
+                    f"invalid questions JSON on line {line_number}: {exc}"
+                ) from exc
+            if not isinstance(row, dict):
+                raise LauncherError(f"questions line {line_number} is not an object")
+            missing = {"n", "ineq", "conditions"}.difference(row)
+            if missing:
+                raise LauncherError(
+                    f"questions line {line_number} is missing: {sorted(missing)}"
+                )
+            if not isinstance(row["conditions"], list):
+                raise LauncherError(
+                    f"questions line {line_number} conditions must be a list"
+                )
+            count += 1
+            ids += int("id" in row)
+            try:
+                variable_counts.append(int(row["n"]))
+            except (TypeError, ValueError) as exc:
+                raise LauncherError(
+                    f"questions line {line_number} has invalid n={row['n']!r}"
+                ) from exc
+            extra_fields.update(set(row).difference({"n", "ineq", "conditions"}))
+    if count == 0:
+        raise LauncherError(f"questions file is empty: {path}")
+    return {
+        "rows": count,
+        "rows_with_id": ids,
+        "min_n": min(variable_counts),
+        "max_n": max(variable_counts),
+        "extra_fields_preserved_by_runner_input": sorted(extra_fields),
+    }
+
+
+def _count_jsonl_rows(path: Path) -> int:
+    with path.open("r", encoding="utf-8") as stream:
+        return sum(1 for line in stream if line.strip())
+
+
+def _read_jsonl(path: Path, label: str) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, start=1):
+            if not line.strip():
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise LauncherError(
+                    f"invalid {label} JSON on line {line_number}: {exc}"
+                ) from exc
+            if not isinstance(row, dict):
+                raise LauncherError(f"{label} line {line_number} is not an object")
+            rows.append(row)
+    return rows
+
+
+def _resume_artifact(
+    results: Path, questions: Path, expected_rows: int
+) -> dict[str, Any]:
+    """Validate and snapshot the immutable prefix used by v12 resume."""
+
+    if not results.is_file() or results.stat().st_size == 0:
+        raise LauncherError(
+            f"--resume requires an existing nonempty results file: {results}"
+        )
+    # Appending to an unterminated final line would corrupt that JSON object.
+    with results.open("rb") as stream:
+        stream.seek(-1, os.SEEK_END)
+        if stream.read(1) not in {b"\n", b"\r"}:
+            raise LauncherError("resume results must end with a newline")
+
+    prior_rows = _read_jsonl(results, "resume results")
+    if not prior_rows:
+        raise LauncherError(
+            f"--resume requires at least one existing result row: {results}"
+        )
+    if len(prior_rows) >= expected_rows:
+        raise LauncherError(
+            "--resume requires fewer existing result rows than questions: "
+            f"results={len(prior_rows)}, questions={expected_rows}"
+        )
+
+    question_rows = _read_jsonl(questions, "questions")
+    for index, (result, question) in enumerate(
+        zip(prior_rows, question_rows, strict=False), start=1
+    ):
+        if result.get("input") != question:
+            raise LauncherError(
+                "resume results are not the exact question-prefix at row "
+                f"{index}; refusing count-based resume"
+            )
+
+    artifact = _file_artifact(results)
+    artifact["rows"] = len(prior_rows)
+    return artifact
+
+
+def _prefix_is_unchanged(path: Path, prior: dict[str, Any]) -> bool:
+    expected_bytes = int(prior["bytes"])
+    if not path.is_file() or path.stat().st_size < expected_bytes:
+        return False
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        remaining = expected_bytes
+        while remaining:
+            chunk = stream.read(min(1024 * 1024, remaining))
+            if not chunk:
+                return False
+            digest.update(chunk)
+            remaining -= len(chunk)
+    return digest.hexdigest() == prior["sha256"]
+
+
+def _resolve_existing(path: Path, label: str) -> Path:
+    resolved = path.expanduser().resolve()
+    if not resolved.is_file():
+        raise LauncherError(f"{label} does not exist or is not a file: {resolved}")
+    return resolved
+
+
+def _parse_gpu_ids(raw: str, workers: int) -> list[int]:
+    try:
+        ids = [int(part.strip()) for part in raw.split(",") if part.strip()]
+    except ValueError as exc:
+        raise LauncherError(f"invalid --gpu-ids value: {raw!r}") from exc
+    if workers <= 0:
+        raise LauncherError("--workers must be positive")
+    if len(ids) < workers:
+        raise LauncherError(
+            f"--workers={workers} requires at least {workers} GPU IDs; got {ids}"
+        )
+    return ids[:workers]
+
+
+def _display_command(command: Sequence[str]) -> str:
+    if os.name == "nt":
+        return subprocess.list2cmdline(list(command))
+    return shlex.join(command)
+
+
+def _git_metadata(repo_root: Path) -> dict[str, Any]:
+    def run(*args: str) -> str | None:
+        try:
+            completed = subprocess.run(
+                ["git", *args],
+                cwd=repo_root,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+        except (OSError, subprocess.SubprocessError):
+            return None
+        return completed.stdout.strip() if completed.returncode == 0 else None
+
+    status = run("status", "--porcelain=v1", "--untracked-files=all")
+    return {
+        "root": str(repo_root),
+        "commit": run("rev-parse", "HEAD"),
+        "branch": run("branch", "--show-current"),
+        "status_porcelain": status,
+        "dirty": bool(status) if status is not None else None,
+    }
+
+
+def _package_metadata() -> dict[str, str | None]:
+    versions: dict[str, str | None] = {}
+    for name in PACKAGE_NAMES:
+        try:
+            versions[name] = importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            versions[name] = None
+    return versions
+
+
+def _hardware_metadata(gpu_ids: Sequence[int]) -> dict[str, Any]:
+    metadata: dict[str, Any] = {
+        "platform": platform.platform(),
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+        "cpu_count": os.cpu_count(),
+        "requested_gpu_ids": list(gpu_ids),
+    }
+    query = [
+        "nvidia-smi",
+        "--query-gpu=index,name,uuid,memory.total,driver_version",
+        "--format=csv,noheader,nounits",
+    ]
+    try:
+        completed = subprocess.run(
+            query, check=False, capture_output=True, text=True, timeout=10
+        )
+        metadata["nvidia_smi_return_code"] = completed.returncode
+        metadata["nvidia_smi"] = [
+            line.strip() for line in completed.stdout.splitlines() if line.strip()
+        ]
+        if completed.stderr.strip():
+            metadata["nvidia_smi_stderr"] = completed.stderr.strip()
+    except (OSError, subprocess.SubprocessError) as exc:
+        metadata["nvidia_smi_error"] = f"{type(exc).__name__}: {exc}"
+    return metadata
+
+
+def _launch_gpu_snapshot(gpu_ids: Sequence[int]) -> list[dict[str, Any]]:
+    """Capture physical-GPU state once, immediately before child launch."""
+
+    requested = list(dict.fromkeys(int(value) for value in gpu_ids))
+    inventory_command = [
+        "nvidia-smi",
+        "--query-gpu=index,uuid,memory.used,memory.free,utilization.gpu",
+        "--format=csv,noheader,nounits",
+    ]
+    apps_command = [
+        "nvidia-smi",
+        "--query-compute-apps=gpu_uuid,pid,process_name,used_gpu_memory",
+        "--format=csv,noheader,nounits",
+    ]
+    inventory: dict[int, dict[str, Any]] = {}
+    apps_by_uuid: dict[str, list[dict[str, Any]]] = {}
+    error: str | None = None
+    try:
+        inventory_result = subprocess.run(
+            inventory_command,
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        for row in csv.reader(inventory_result.stdout.splitlines(), skipinitialspace=True):
+            if not row:
+                continue
+            if len(row) != 5:
+                raise ValueError(f"malformed GPU inventory row: {row!r}")
+            index = int(row[0].strip())
+            inventory[index] = {
+                "index": index,
+                "uuid": row[1].strip(),
+                "memory_used_mib": int(row[2].strip()),
+                "memory_free_mib": int(row[3].strip()),
+                "utilization_percent": int(row[4].strip()),
+            }
+        apps_result = subprocess.run(
+            apps_command,
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        for row in csv.reader(apps_result.stdout.splitlines(), skipinitialspace=True):
+            if not row:
+                continue
+            if len(row) != 4:
+                raise ValueError(f"malformed compute-app row: {row!r}")
+            uuid_value = row[0].strip()
+            apps_by_uuid.setdefault(uuid_value, []).append(
+                {
+                    "pid": row[1].strip(),
+                    "process_name": row[2].strip(),
+                    "used_gpu_memory_mib": row[3].strip(),
+                }
+            )
+    except (OSError, ValueError, subprocess.SubprocessError) as exc:
+        error = f"{type(exc).__name__}: {exc}"
+
+    snapshot: list[dict[str, Any]] = []
+    for index in requested:
+        gpu = inventory.get(
+            index,
+            {
+                "index": index,
+                "uuid": None,
+                "memory_used_mib": None,
+                "memory_free_mib": None,
+                "utilization_percent": None,
+            },
+        )
+        item = {**gpu, "compute_apps": apps_by_uuid.get(str(gpu["uuid"]), [])}
+        if error is not None:
+            item["snapshot_error"] = error
+        snapshot.append(item)
+    return snapshot
+
+
+def _require_complete_launch_gpu_snapshot(
+    snapshot: Sequence[dict[str, Any]], gpu_ids: Sequence[int]
+) -> None:
+    """Fail before child start unless every selected physical GPU is identified."""
+
+    by_index = {
+        item.get("index"): item
+        for item in snapshot
+        if isinstance(item, dict) and isinstance(item.get("index"), int)
+    }
+    for gpu_id in dict.fromkeys(int(value) for value in gpu_ids):
+        item = by_index.get(gpu_id)
+        if item is None:
+            raise LauncherError(f"launch GPU snapshot is missing physical GPU {gpu_id}")
+        if item.get("snapshot_error"):
+            raise LauncherError(
+                f"launch GPU snapshot failed for physical GPU {gpu_id}: "
+                f"{item['snapshot_error']}"
+            )
+        if not isinstance(item.get("uuid"), str) or not item["uuid"]:
+            raise LauncherError(
+                f"launch GPU snapshot has no UUID for physical GPU {gpu_id}"
+            )
+
+
+def _base_model(checkpoint: Path) -> str | None:
+    config_path = checkpoint / "adapter_config.json" if checkpoint.is_dir() else None
+    if config_path is None or not config_path.is_file():
+        return None
+    try:
+        config = json.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    value = config.get("base_model_name_or_path") if isinstance(config, dict) else None
+    return str(value) if value is not None else None
+
+
+def _write_manifest(path: Path, manifest: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(path.name + f".tmp-{os.getpid()}-{uuid.uuid4().hex}")
+    temporary.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(path)
+
+
+def _write_manifest_exclusive(path: Path, manifest: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        with path.open("x", encoding="utf-8") as stream:
+            json.dump(manifest, stream, ensure_ascii=False, indent=2, sort_keys=True)
+            stream.write("\n")
+    except FileExistsError as exc:
+        raise LauncherError(f"manifest already exists: {path}") from exc
+
+
+def build_command(
+    args: argparse.Namespace,
+    *,
+    questions: Path,
+    results: Path,
+    checkpoint: Path,
+    runner: Path,
+    gpu_ids: Sequence[int],
+    execution_config_manifest: Path | None = None,
+) -> tuple[list[str], dict[str, str]]:
+    """Build the exact child-process command and search-sensitive environment."""
+
+    command = [
+        sys.executable,
+        str(runner),
+        "--input",
+        str(questions),
+        "--output",
+        str(results),
+        "--min-n",
+        str(args.min_n),
+        "--max-n",
+        str(args.max_n),
+        "--max-depth",
+        str(args.max_depth),
+        "--rollouts",
+        str(args.rollouts),
+        "--k-per-node",
+        "1",
+        "--llm-mode",
+        "batch",
+        "--beam-size",
+        str(args.beam_size),
+        "--gpu-workers",
+        str(args.workers),
+        "--gpu-devices",
+        ",".join(str(value) for value in gpu_ids),
+        "--adapter-path",
+        str(checkpoint),
+        "--lp-workers",
+        str(args.lp_workers),
+        "--enable-lp",
+        "--max-vars-for-lp",
+        str(args.max_vars_for_lp),
+        "--max-new-tokens",
+        str(args.max_new_tokens),
+        "--max-time",
+        str(args.generation_max_time),
+        "--seed",
+        str(args.seed),
+        "--sample-max-tree-size",
+        str(args.sample_max_tree_size),
+        "--sample-max-time-sec",
+        str(args.sample_max_time_sec),
+    ]
+    if args.print_llm:
+        command.append("--print-llm")
+    if args.sample_max_llm_calls is not None:
+        command.extend(["--sample-max-llm-calls", str(args.sample_max_llm_calls)])
+    if execution_config_manifest is not None:
+        command.extend(
+            ["--execution-config-manifest", str(execution_config_manifest)]
+        )
+    if args.resume:
+        command.extend(["--append", "--resume-from-output"])
+
+    environment = {
+        "BEAM_PROMPT_FORMAT": args.prompt_format,
+        "BEAM_NORMALIZE_CANDIDATES": "1" if args.normalize_candidates else "0",
+        "BEAM_SORT_ALPHA_GROUPS": "0",
+        "BEAM_RANDOM_SCORE": "0",
+        "BEAM_MAX_TRIES_PER_STEP": "3",
+        "QWEN_TEMPERATURE": str(args.temperature),
+        "QWEN_TOP_P": "0.9",
+        "QWEN_MAX_NEW_TOKENS": str(args.max_new_tokens),
+        "QWEN_MAX_TIME": str(args.generation_max_time),
+        "QWEN_RAW_PROMPT": "1" if args.raw_prompt else "0",
+        "QWEN_PRINT_PROMPT": "0",
+        "QWEN_ADAPTER_PATH": str(checkpoint),
+        # Prefer the explicit pinned local snapshot and otherwise prevent
+        # unrelated shell state from replacing the adapter-declared base.
+        "QWEN_BASE_MODEL": str(args.base_model) if args.base_model else "",
+        "QWEN_WEIGHTS_PATH": "",
+        "GPU_DEVICES": ",".join(str(value) for value in gpu_ids),
+    }
+    return command, environment
+
+
+def _settings(args: argparse.Namespace, gpu_ids: Sequence[int]) -> dict[str, Any]:
+    return {
+        "beam_size": args.beam_size,
+        "rollouts": args.rollouts,
+        "max_depth": args.max_depth,
+        "seed": args.seed,
+        "workers": args.workers,
+        "gpu_ids": list(gpu_ids),
+        "temperature": args.temperature,
+        "base_model": str(args.base_model) if args.base_model else None,
+        "max_new_tokens": args.max_new_tokens,
+        "generation_max_time_sec": args.generation_max_time,
+        "sample_max_tree_size": args.sample_max_tree_size,
+        "sample_max_time_sec": args.sample_max_time_sec,
+        "hard_question_timeout_sec": args.hard_question_timeout_sec,
+        "sample_max_llm_calls": int(args.sample_max_llm_calls or 0),
+        "max_vars_for_lp": args.max_vars_for_lp,
+        "lp_enabled": True,
+        "lp_workers": args.lp_workers,
+        "lp_execution": "synchronous",
+        "prompt_format": args.prompt_format,
+        "normalize_candidates": args.normalize_candidates,
+        "raw_prompt": args.raw_prompt,
+        "print_llm": args.print_llm,
+        "top_p": 0.9,
+        "sort_alpha_groups": False,
+        "random_score": False,
+        "max_tries_per_step": 3,
+        "min_n": args.min_n,
+        "max_n": args.max_n,
+        "llm_mode": "batch",
+        "k_per_node": 1,
+        "random_prune": False,
+        "prune_seed": None,
+        "sample_max_llm_fails": 0,
+        "depth1_rollouts": None,
+        "per_n_budget": {},
+        "include_proof_trace": False,
+        "limit": 0,
+        "use_dummy": False,
+        "debug_search": False,
+        "log_every": 1,
+        "log_wrong_pruned": False,
+        "wrong_pruned_path": "",
+    }
+
+
+def _normalized_command(command: Sequence[str]) -> list[str]:
+    normalized = list(command)
+    if "--execution-config-manifest" in normalized:
+        index = normalized.index("--execution-config-manifest")
+        if index + 1 < len(normalized):
+            normalized[index + 1] = "<live-wrapper-manifest>"
+    return normalized
+
+
+def _execution_config(
+    *,
+    invocation_id: str,
+    recorded_utc: str,
+    origin: str,
+    repo_root: Path,
+    repository: dict[str, Any],
+    runner: Path,
+    runner_artifact: dict[str, Any],
+    checkpoint: Path,
+    checkpoint_artifact: dict[str, Any],
+    settings: dict[str, Any],
+    gpu_ids: Sequence[int],
+    inherited_environment: dict[str, str | None],
+    gpu_snapshot: list[dict[str, Any]],
+    command: Sequence[str],
+) -> dict[str, Any]:
+    uuid_by_index = {
+        item.get("index"): item.get("uuid")
+        for item in gpu_snapshot
+        if isinstance(item, dict)
+    }
+    return {
+        "schema_version": EXECUTION_CONFIG_SCHEMA_VERSION,
+        "invocation_id": invocation_id,
+        "recorded_utc": recorded_utc,
+        "origin": origin,
+        "code": {
+            "git_commit": repository.get("commit"),
+            "repo_root": str(repo_root),
+            "runner_path": str(runner),
+            "runner_sha256": runner_artifact["sha256"],
+        },
+        "model": {
+            "checkpoint_path": str(checkpoint),
+            "checkpoint_sha256": checkpoint_artifact["sha256"],
+            "base_model": settings.get("base_model") or _base_model(checkpoint),
+        },
+        "search": settings,
+        "resources": {
+            "workers": len(gpu_ids),
+            "gpu_ids": list(gpu_ids),
+            "worker_device_mapping": [
+                {
+                    "worker_index": worker_index,
+                    "physical_gpu_index": gpu_id,
+                    "gpu_uuid": uuid_by_index.get(gpu_id),
+                }
+                for worker_index, gpu_id in enumerate(gpu_ids)
+            ],
+            "cuda_visible_devices": inherited_environment.get(
+                "CUDA_VISIBLE_DEVICES"
+            ),
+            "launch_gpu_snapshot": gpu_snapshot,
+        },
+        "normalized_command": _normalized_command(command),
+    }
+
+
+def _resource_policy(args: argparse.Namespace) -> dict[str, Any]:
+    """Describe the frozen reviewer budget and its enforcement boundary."""
+
+    return {
+        "policy_version": RESOURCE_POLICY_VERSION,
+        "sample_max_time_sec": args.sample_max_time_sec,
+        "hard_question_timeout_sec": args.hard_question_timeout_sec,
+        "sample_max_tree_size": args.sample_max_tree_size,
+        "sample_max_llm_calls": args.sample_max_llm_calls,
+        "time_enforcement": "cooperative_soft",
+        "tree_enforcement": "cooperative_soft",
+        "hard_wall_time_enforced": False,
+        "external_hard_timeout_required": True,
+        "interpretation": (
+            "The tracked runner checks elapsed time and tree size between search "
+            "operations. Already submitted model generations can finish after a "
+            "budget is reached, so neither limit is an external hard kill."
+        ),
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Run and document the submitted proposed-model v12 search."
+    )
+    parser.add_argument("--questions", type=Path, required=True)
+    parser.add_argument("--results", type=Path, required=True)
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument(
+        "--base-model",
+        type=Path,
+        help=(
+            "Local base-model snapshot. When supplied, QWEN_BASE_MODEL is set "
+            "to this resolved directory instead of the adapter-declared Hub ID."
+        ),
+    )
+    parser.add_argument("--runner", type=Path, default=DEFAULT_RUNNER)
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        help="Run manifest path (default: RESULTS.run-manifest.json)",
+    )
+    parser.add_argument("--gpu-ids", default=DEFAULT_GPU_IDS)
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("--beam-size", type=int, default=32)
+    parser.add_argument("--rollouts", type=int, default=6)
+    parser.add_argument("--max-depth", type=int, default=24)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--temperature", type=float, default=1.2)
+    parser.add_argument("--max-new-tokens", type=int, default=2048)
+    parser.add_argument("--generation-max-time", type=float, default=20.0)
+    parser.add_argument(
+        "--sample-max-tree-size",
+        type=int,
+        default=SAMPLE_MAX_TREE_SIZE,
+        help=(
+            "Cooperative per-sample tree budget. The value is recorded in every "
+            "result row and may change on a later resume."
+        ),
+    )
+    parser.add_argument("--max-vars-for-lp", type=int, default=0)
+    parser.add_argument("--lp-workers", type=int, default=8)
+    parser.add_argument("--min-n", type=int, default=3)
+    parser.add_argument("--max-n", type=int, default=15)
+    parser.add_argument("--prompt-format", default="canonical")
+    parser.add_argument(
+        "--normalize-candidates",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+    )
+    parser.add_argument("--raw-prompt", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--print-llm", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument(
+        "--sample-max-time-sec",
+        type=float,
+        default=SAMPLE_MAX_TIME_SEC,
+        help=(
+            "Cooperative per-sample time budget. The value is recorded in every "
+            "result row and may change on a later resume; it is not an external "
+            "hard kill."
+        ),
+    )
+    parser.add_argument(
+        "--hard-question-timeout-sec",
+        type=float,
+        default=None,
+        help=(
+            "External supervisor hard timeout recorded in per-row configuration. "
+            "This wrapper does not itself enforce the hard kill."
+        ),
+    )
+    parser.add_argument(
+        "--sample-max-llm-calls",
+        type=int,
+        default=None,
+        help="Optional per-sample LLM-call cap; omitted by default.",
+    )
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help=(
+            "Safely append after an existing nonempty result prefix. The wrapper "
+            "validates the prefix and passes v12 --append --resume-from-output."
+        ),
+    )
+    parser.add_argument(
+        "--resume-source-manifest",
+        type=Path,
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--allow-resume-resource-change",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Allow replacing an existing results file or manifest.",
+    )
+    return parser
+
+
+def _validate_numeric_args(args: argparse.Namespace) -> None:
+    positive = {
+        "beam-size": args.beam_size,
+        "rollouts": args.rollouts,
+        "max-depth": args.max_depth,
+        "max-new-tokens": args.max_new_tokens,
+        "generation-max-time": args.generation_max_time,
+        "sample-max-tree-size": args.sample_max_tree_size,
+    }
+    for label, value in positive.items():
+        if value <= 0:
+            raise LauncherError(f"--{label} must be positive")
+    if args.sample_max_time_sec is None or args.sample_max_time_sec <= 0:
+        raise LauncherError("--sample-max-time-sec must be positive and bounded")
+    if (
+        args.hard_question_timeout_sec is not None
+        and args.hard_question_timeout_sec <= 0
+    ):
+        raise LauncherError("--hard-question-timeout-sec must be positive when set")
+    if args.sample_max_llm_calls is not None and args.sample_max_llm_calls <= 0:
+        raise LauncherError("--sample-max-llm-calls must be positive when supplied")
+
+
+def _exact_verify(results: Path) -> dict[str, Any]:
+    from beam_search_model2.verify_proof_certificate import verify_jsonl
+
+    valid, invalid, errors, skipped = verify_jsonl(results)
+    return {
+        "valid": valid,
+        "invalid": invalid,
+        "errors": errors,
+        "skipped_unproved": skipped,
+        "passed": invalid == 0 and errors == 0,
+        "verifier": "beam_search_model2.verify_proof_certificate.verify_jsonl",
+    }
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        _validate_numeric_args(args)
+        if args.resume and args.overwrite:
+            raise LauncherError("--resume and --overwrite are mutually exclusive")
+        repo_root = Path(__file__).resolve().parents[2]
+        questions = _resolve_existing(args.questions, "questions file")
+        runner_candidate = (
+            repo_root / args.runner if args.runner == DEFAULT_RUNNER else args.runner
+        )
+        runner = _resolve_existing(runner_candidate, "runner")
+        checkpoint = args.checkpoint.expanduser().resolve()
+        if args.base_model is not None:
+            args.base_model = args.base_model.expanduser().resolve()
+            if not args.base_model.is_dir():
+                raise LauncherError(
+                    f"base-model snapshot does not exist or is not a directory: "
+                    f"{args.base_model}"
+                )
+        results = args.results.expanduser().resolve()
+        gpu_ids = _parse_gpu_ids(args.gpu_ids, args.workers)
+        profile = _question_profile(questions)
+        resume_prior: dict[str, Any] | None = None
+        prior_verification: dict[str, Any] | None = None
+        if args.resume:
+            resume_prior = _resume_artifact(results, questions, profile["rows"])
+            try:
+                prior_verification = _exact_verify(results)
+            except Exception as exc:
+                raise LauncherError(
+                    "could not exactly verify resume prefix: "
+                    f"{type(exc).__name__}: {exc}"
+                ) from exc
+            if not prior_verification["passed"]:
+                raise LauncherError(
+                    "resume prefix failed exact verification; refusing to append"
+                )
+
+        invocation_id = uuid.uuid4().hex
+        recorded_utc = _utc_now()
+        manifest_path = (
+            args.manifest.expanduser().resolve()
+            if args.manifest
+            else results.with_name(
+                f"{results.name}.{invocation_id}.run-manifest.json"
+            )
+        )
+
+        if results in {questions, runner, manifest_path}:
+            raise LauncherError("results path must be distinct from inputs and manifest")
+        if manifest_path in {questions, runner}:
+            raise LauncherError("manifest path must be distinct from input files")
+        if results.is_dir():
+            raise LauncherError(f"results path is a directory: {results}")
+        if manifest_path.is_dir():
+            raise LauncherError(f"manifest path is a directory: {manifest_path}")
+        if checkpoint.is_dir() and (
+            results.is_relative_to(checkpoint) or manifest_path.is_relative_to(checkpoint)
+        ):
+            raise LauncherError("results and manifest must not be written inside checkpoint")
+
+        if manifest_path.exists():
+            raise LauncherError(f"manifest already exists: {manifest_path}")
+        if (
+            not args.dry_run
+            and results.exists()
+            and not args.overwrite
+            and not args.resume
+        ):
+            raise LauncherError(
+                f"results already exist; pass --overwrite to replace them: {results}"
+            )
+
+        if profile["min_n"] < args.min_n or profile["max_n"] > args.max_n:
+            raise LauncherError(
+                "questions contain n outside the configured runner filter: "
+                f"questions={profile['min_n']}..{profile['max_n']}, "
+                f"filter={args.min_n}..{args.max_n}"
+            )
+        checkpoint_info = _checkpoint_artifact(checkpoint)
+        runner_info = _file_artifact(runner)
+        repository = _git_metadata(repo_root)
+        inherited_environment = {
+            name: os.environ.get(name) for name in RELEVANT_INHERITED_ENV
+        }
+        settings = _settings(args, gpu_ids)
+        runtime_environment: dict[str, Any] | None = None
+        if not args.dry_run:
+            runtime_environment = {
+                "python": {
+                    "executable": sys.executable,
+                    "version": sys.version,
+                    "implementation": platform.python_implementation(),
+                },
+                "packages": _package_metadata(),
+                "hardware": _hardware_metadata(gpu_ids),
+            }
+        # Keep this as the final hardware query before manifest publication and
+        # child start; rows describe launch-time state, not an earlier preflight.
+        gpu_snapshot = _launch_gpu_snapshot(gpu_ids)
+        if not args.dry_run:
+            _require_complete_launch_gpu_snapshot(gpu_snapshot, gpu_ids)
+        command, environment = build_command(
+            args,
+            questions=questions,
+            results=results,
+            checkpoint=checkpoint,
+            runner=runner,
+            gpu_ids=gpu_ids,
+            execution_config_manifest=manifest_path,
+        )
+        execution_config = _execution_config(
+            invocation_id=invocation_id,
+            recorded_utc=recorded_utc,
+            origin="resume" if args.resume else "fresh",
+            repo_root=repo_root,
+            repository=repository,
+            runner=runner,
+            runner_artifact=runner_info,
+            checkpoint=checkpoint,
+            checkpoint_artifact=checkpoint_info,
+            settings=settings,
+            gpu_ids=gpu_ids,
+            inherited_environment=inherited_environment,
+            gpu_snapshot=gpu_snapshot,
+            command=command,
+        )
+        plan = {
+            "command": command,
+            "command_display": _display_command(command),
+            "cwd": str(repo_root),
+            "environment_overrides": environment,
+            "inherited_environment_relevant": inherited_environment,
+            "settings": settings,
+        }
+        manifest: dict[str, Any] = {
+            "schema_version": SCHEMA_VERSION,
+            "execution_config": execution_config,
+            "mode": "dry-run" if args.dry_run else "execute",
+            "status": "planned" if args.dry_run else "preparing",
+            "plan": plan,
+            "artifacts": {
+                "questions": _file_artifact(questions),
+                "runner": runner_info,
+                "checkpoint": checkpoint_info,
+                "results_path": str(results),
+                "manifest_path": str(manifest_path),
+            },
+            "questions": profile,
+            "resource_policy": _resource_policy(args),
+        }
+        if resume_prior is not None:
+            manifest["resume"] = {
+                "enabled": True,
+                "prior_results": resume_prior,
+                "prior_exact_verification": prior_verification,
+                "remaining_rows": profile["rows"] - int(resume_prior["rows"]),
+                "runner_flags": ["--append", "--resume-from-output"],
+                "manifest_policy": (
+                    "Resume trusts no earlier configuration. The exact input prefix "
+                    "and proof certificates are validated, and this invocation is "
+                    "self-described by its own unique manifest."
+                ),
+            }
+
+        if args.dry_run:
+            _write_manifest_exclusive(manifest_path, manifest)
+            print(json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True))
+            return 0
+
+        results.parent.mkdir(parents=True, exist_ok=True)
+        manifest["repository"] = repository
+        manifest["runtime_environment"] = runtime_environment
+        manifest["status"] = "running"
+        manifest["runtime"] = {"started_utc": recorded_utc}
+        # The supervisor reads this live manifest to stamp synthetic timeout
+        # rows, so execution_config must be authoritative before child start.
+        _write_manifest_exclusive(manifest_path, manifest)
+
+        child_environment = os.environ.copy()
+        child_environment.update(environment)
+        started = time.perf_counter()
+        try:
+            completed = subprocess.run(
+                command,
+                cwd=repo_root,
+                env=child_environment,
+                check=False,
+            )
+            return_code = completed.returncode
+        except KeyboardInterrupt:
+            return_code = 130
+            manifest["status"] = "interrupted"
+        except OSError as exc:
+            return_code = 127
+            manifest["status"] = "runner_failed"
+            manifest["runtime"]["launch_error"] = f"{type(exc).__name__}: {exc}"
+        wall_time = time.perf_counter() - started
+        manifest["runtime"].update(
+            {
+                "ended_utc": _utc_now(),
+                "wall_time_sec": wall_time,
+                "return_code": return_code,
+            }
+        )
+
+        prefix_unchanged = (
+            _prefix_is_unchanged(results, resume_prior)
+            if resume_prior is not None
+            else None
+        )
+        if resume_prior is not None:
+            manifest["resume"]["prior_prefix_unchanged"] = prefix_unchanged
+
+        if return_code == 0:
+            if not results.is_file():
+                manifest["status"] = "verification_failed"
+                manifest["exact_verification"] = {
+                    "passed": False,
+                    "error": "runner returned zero but did not create the results file",
+                }
+                final_code = 4
+            else:
+                manifest["artifacts"]["results"] = _file_artifact(results)
+                result_rows = _count_jsonl_rows(results)
+                manifest["artifacts"]["results"]["rows"] = result_rows
+                try:
+                    verification = _exact_verify(results)
+                except Exception as exc:  # Preserve the run even if verifier setup fails.
+                    verification = {
+                        "passed": False,
+                        "error": f"{type(exc).__name__}: {exc}",
+                    }
+                manifest["exact_verification"] = verification
+                manifest["result_completeness"] = {
+                    "expected_rows": profile["rows"],
+                    "actual_rows": result_rows,
+                    "passed": result_rows == profile["rows"],
+                }
+                if (
+                    verification["passed"]
+                    and result_rows == profile["rows"]
+                    and prefix_unchanged is not False
+                ):
+                    manifest["status"] = "succeeded"
+                    final_code = 0
+                else:
+                    manifest["status"] = "verification_failed"
+                    final_code = 4
+        else:
+            manifest["status"] = (
+                manifest["status"] if manifest["status"] == "interrupted" else "runner_failed"
+            )
+            if results.is_file():
+                manifest["artifacts"]["partial_results"] = _file_artifact(results)
+            final_code = return_code
+
+        _write_manifest(manifest_path, manifest)
+        print(json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True))
+        return final_code
+    except LauncherError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mce220_runner/experiments/reviewer_response/supervise_search_benchmark.py

@@ -0,0 +1,780 @@
+"""Externally enforce a hard per-question limit for the v12 search launcher.
+
+The submitted runner's time budget is cooperative: model calls already in flight
+may finish after it expires.  This supervisor leaves that runner and its
+reproducibility wrapper unchanged.  It watches the wrapper's streamed JSONL
+output, kills the complete child process tree at a hard deadline, records a
+schema-compatible timeout row for the exact pending input, and starts a new
+wrapper resume segment at the following question.
+
+Every invocation and process segment gets a collision-resistant identity and
+new, never-overwritten logs and manifests. The result prefix is authoritative:
+the mutable state file may be absent, stale, or left by a different invocation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Sequence
+
+
+SCHEMA_VERSION = "reviewer-hard-supervisor-v2"
+ATTEMPT_SCHEMA_VERSION = "reviewer-hard-supervisor-attempt-v2"
+EXECUTION_CONFIG_SCHEMA_VERSION = "e2n-execution-config-v1"
+QUESTION_TIMEOUT_SEC = 1000.0
+TREE_SIZE_CAP = 6000
+TOTAL_JOB_STOP_SEC = 42.0 * 60.0 * 60.0
+DEFAULT_LAUNCHER = Path("experiments/reviewer_response/run_search_benchmark.py")
+
+
+class SupervisorError(ValueError):
+    """Raised when an artifact or resume prefix is unsafe."""
+
+
+@dataclass(frozen=True)
+class Question:
+    row: dict[str, Any]
+    source_line_number: int
+    input_sha256: str
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _artifact(path: Path) -> dict[str, Any]:
+    return {
+        "path": str(path),
+        "bytes": path.stat().st_size,
+        "sha256": _sha256_file(path),
+    }
+
+
+def _write_json_atomic(path: Path, value: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(path.name + f".tmp-{os.getpid()}")
+    temporary.write_text(
+        json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(path)
+
+
+def _write_json_exclusive(path: Path, value: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("x", encoding="utf-8") as stream:
+        json.dump(value, stream, ensure_ascii=False, indent=2, sort_keys=True)
+        stream.write("\n")
+
+
+def _read_questions(path: Path) -> list[Question]:
+    questions: list[Question] = []
+    ids: set[str] = set()
+    with path.open("rb") as stream:
+        for source_line_number, raw in enumerate(stream, start=1):
+            stripped = raw.strip()
+            if not stripped:
+                continue
+            try:
+                row = json.loads(stripped.decode("utf-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+                raise SupervisorError(
+                    f"invalid question JSON on source line {source_line_number}: {exc}"
+                ) from exc
+            if not isinstance(row, dict):
+                raise SupervisorError(
+                    f"question source line {source_line_number} is not an object"
+                )
+            missing = {"id", "n", "ineq", "conditions"}.difference(row)
+            if missing:
+                raise SupervisorError(
+                    f"question source line {source_line_number} is missing {sorted(missing)}"
+                )
+            question_id = row["id"]
+            if not isinstance(question_id, str) or not question_id:
+                raise SupervisorError(
+                    f"question source line {source_line_number} has an invalid id"
+                )
+            if question_id in ids:
+                raise SupervisorError(f"duplicate question id: {question_id}")
+            ids.add(question_id)
+            if not isinstance(row["conditions"], list):
+                raise SupervisorError(f"question {question_id} conditions is not a list")
+            questions.append(
+                Question(
+                    row=row,
+                    source_line_number=source_line_number,
+                    input_sha256=hashlib.sha256(stripped).hexdigest(),
+                )
+            )
+    if not questions:
+        raise SupervisorError(f"questions file is empty: {path}")
+    return questions
+
+
+def _read_complete_result_rows(path: Path) -> tuple[list[dict[str, Any]], int]:
+    """Read newline-terminated rows and return their safe byte boundary.
+
+    A final unterminated line is ignored while a child may be writing it.  Any
+    malformed *terminated* row is an artifact error, never a reason to skip an
+    input by count.
+    """
+
+    if not path.exists():
+        return [], 0
+    rows: list[dict[str, Any]] = []
+    safe_bytes = 0
+    with path.open("rb") as stream:
+        while True:
+            raw = stream.readline()
+            if not raw:
+                break
+            if not raw.endswith((b"\n", b"\r")):
+                break
+            safe_bytes = stream.tell()
+            if not raw.strip():
+                continue
+            try:
+                row = json.loads(raw.decode("utf-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+                raise SupervisorError(
+                    f"malformed terminated result row {len(rows) + 1}: {exc}"
+                ) from exc
+            if not isinstance(row, dict):
+                raise SupervisorError(f"result row {len(rows) + 1} is not an object")
+            rows.append(row)
+    return rows, safe_bytes
+
+
+def _validate_prefix(
+    results: Path, questions: Sequence[Question], *, require_terminated: bool
+) -> list[dict[str, Any]]:
+    rows, safe_bytes = _read_complete_result_rows(results)
+    if results.exists() and require_terminated and results.stat().st_size != safe_bytes:
+        raise SupervisorError("results end in an incomplete JSONL row")
+    if len(rows) > len(questions):
+        raise SupervisorError(
+            f"results contain more rows than questions: {len(rows)} > {len(questions)}"
+        )
+    seen_ids: set[str] = set()
+    for index, (result, question) in enumerate(zip(rows, questions), start=1):
+        if result.get("input") != question.row:
+            raise SupervisorError(
+                f"result row {index} is not the exact frozen question prefix"
+            )
+        result_id = result["input"].get("id")
+        if result_id != question.row["id"]:
+            raise SupervisorError(f"result row {index} has a mismatched question id")
+        if result_id in seen_ids:
+            raise SupervisorError(f"duplicate result id: {result_id}")
+        seen_ids.add(result_id)
+        if "input_sha256" in result and result["input_sha256"] != question.input_sha256:
+            raise SupervisorError(f"result row {index} has a mismatched input_sha256")
+    return rows
+
+
+def _timeout_row(
+    question: Question,
+    *,
+    timeout_sec: float,
+    observed_wall_sec: float,
+    attempt_number: int,
+    execution_config: dict[str, Any],
+    tree_size_cap: int = TREE_SIZE_CAP,
+) -> dict[str, Any]:
+    row = question.row
+    return {
+        "source_line_number": question.source_line_number,
+        "input_sha256": question.input_sha256,
+        "input": row,
+        "mapped": {
+            "ineq": row["ineq"],
+            "n": int(row["n"]),
+            "mapping": {},
+        },
+        "run": {
+            "proved": False,
+            "time_sec": float(timeout_sec),
+            "search_time_sec": float(timeout_sec),
+            "tree_size": 0,
+            "expr_str": None,
+            "x": None,
+            "error": (
+                f"ExternalHardTimeout: question exceeded {timeout_sec:g} seconds"
+            ),
+            "llm_usage": {},
+            "stop_reason": "external_hard_timeout",
+            "budget_applied": {
+                "tree_size": tree_size_cap,
+                "time_sec": float(timeout_sec),
+                "llm_calls": 0,
+                "llm_fails": 0,
+                "depth1_rollouts": None,
+                "enforcement": "external_hard_process_tree_kill",
+            },
+            "external_supervision": {
+                "schema_version": SCHEMA_VERSION,
+                "attempt_number": attempt_number,
+                "hard_timeout_sec": float(timeout_sec),
+                "observed_wall_sec": float(observed_wall_sec),
+                "synthetic_result": True,
+            },
+            "execution_config": execution_config,
+        },
+    }
+
+
+def _append_row(path: Path, row: dict[str, Any]) -> None:
+    """Append one complete JSONL row with one O_APPEND write, then fsync it."""
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = (json.dumps(row, ensure_ascii=False) + "\n").encode("utf-8")
+    descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND)
+    try:
+        written = os.write(descriptor, payload)
+        if written != len(payload):
+            raise OSError(
+                "short atomic JSONL append: "
+                f"wrote {written} of {len(payload)} bytes"
+            )
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _popen_group(command: Sequence[str], **kwargs: Any) -> subprocess.Popen[Any]:
+    if os.name == "nt":
+        kwargs["creationflags"] = kwargs.get("creationflags", 0) | subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        kwargs["start_new_session"] = True
+    return subprocess.Popen(list(command), **kwargs)
+
+
+def _kill_process_tree(process: subprocess.Popen[Any], *, grace_sec: float = 3.0) -> None:
+    """Terminate the exact child tree and wait until its root is reaped."""
+
+    # Do not return merely because the group leader has exited. A launcher can
+    # terminate between poll() and this call while one of its workers remains
+    # alive. The process group/tree operation must still be attempted.
+    root_already_exited = process.poll() is not None
+    if os.name == "nt":
+        try:
+            completed = subprocess.run(
+                ["taskkill", "/PID", str(process.pid), "/T", "/F"],
+                check=False,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=max(grace_sec, 1.0),
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise SupervisorError(
+                f"timed out killing launcher process tree rooted at pid {process.pid}"
+            ) from exc
+        if completed.returncode != 0:
+            raise SupervisorError(
+                "taskkill could not confirm termination of launcher process tree "
+                f"rooted at pid {process.pid} (exit {completed.returncode}); "
+                "refusing stale-lock removal or relaunch"
+            )
+    else:
+        try:
+            os.killpg(process.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+        if not root_already_exited:
+            try:
+                process.wait(timeout=grace_sec)
+            except subprocess.TimeoutExpired:
+                pass
+        # The group leader can exit while a worker ignores SIGTERM. Always
+        # follow with SIGKILL for the same isolated process group.
+        try:
+            os.killpg(process.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+    try:
+        process.wait(timeout=max(grace_sec, 1.0))
+    except subprocess.TimeoutExpired as exc:
+        raise SupervisorError(
+            f"could not reap killed launcher process tree rooted at pid {process.pid}"
+        ) from exc
+
+
+def _protected_launcher_args(extra: Sequence[str]) -> None:
+    protected = {
+        "--questions",
+        "--results",
+        "--checkpoint",
+        "--manifest",
+        "--resume",
+        "--resume-source-manifest",
+        "--overwrite",
+        "--sample-max-time-sec",
+        "--hard-question-timeout-sec",
+        "--sample-max-tree-size",
+    }
+    used = sorted(
+        item
+        for item in extra
+        if item in protected or any(item.startswith(flag + "=") for flag in protected)
+    )
+    if used:
+        raise SupervisorError(
+            "launcher arguments may not override supervisor-controlled flags: "
+            + ", ".join(used)
+        )
+
+
+def _timeout_execution_config(
+    wrapper_manifest: Path,
+    *,
+    invocation_id: str,
+    attempt_id: str,
+) -> dict[str, Any]:
+    """Copy and validate the live wrapper config for a synthetic timeout row."""
+
+    try:
+        manifest = json.loads(wrapper_manifest.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise SupervisorError(
+            "cannot stamp synthetic timeout without the authoritative wrapper "
+            f"manifest {wrapper_manifest}: {exc}"
+        ) from exc
+    authoritative = manifest.get("execution_config")
+    if not isinstance(authoritative, dict):
+        raise SupervisorError(
+            "authoritative wrapper manifest has no execution_config object"
+        )
+    required = {
+        "invocation_id",
+        "recorded_utc",
+        "origin",
+        "code",
+        "model",
+        "search",
+        "resources",
+        "normalized_command",
+    }
+    missing = sorted(required.difference(authoritative))
+    if authoritative.get("schema_version") != EXECUTION_CONFIG_SCHEMA_VERSION:
+        raise SupervisorError(
+            "authoritative wrapper execution_config has unsupported schema "
+            f"{authoritative.get('schema_version')!r}"
+        )
+    if missing:
+        raise SupervisorError(
+            "authoritative wrapper execution_config is missing fields: "
+            + ", ".join(missing)
+        )
+    # JSON round-tripping detaches this row from the mutable manifest object.
+    config = json.loads(json.dumps(authoritative, ensure_ascii=False))
+    config["origin"] = "supervisor_synthetic_timeout"
+    config["supervision"] = {
+        "invocation_id": invocation_id,
+        "attempt_id": attempt_id,
+    }
+    return config
+
+
+def _launcher_command(
+    *,
+    launcher: Path,
+    questions: Path,
+    results: Path,
+    checkpoint: Path,
+    wrapper_manifest: Path,
+    launcher_args: Sequence[str],
+    resume: bool,
+    question_timeout_sec: float,
+    tree_size_cap: int = TREE_SIZE_CAP,
+) -> list[str]:
+    command = [
+        sys.executable,
+        str(launcher),
+        "--questions",
+        str(questions),
+        "--results",
+        str(results),
+        "--checkpoint",
+        str(checkpoint),
+        "--manifest",
+        str(wrapper_manifest),
+        "--sample-max-time-sec",
+        str(float(question_timeout_sec)),
+        "--hard-question-timeout-sec",
+        str(float(question_timeout_sec)),
+        "--sample-max-tree-size",
+        str(tree_size_cap),
+        *launcher_args,
+    ]
+    if resume:
+        command.append("--resume")
+    return command
+
+
+def run_supervisor(
+    *,
+    questions_path: Path,
+    results_path: Path,
+    checkpoint: Path,
+    launcher: Path,
+    artifact_dir: Path,
+    state_path: Path,
+    launcher_args: Sequence[str] = (),
+    question_timeout_sec: float = QUESTION_TIMEOUT_SEC,
+    tree_size_cap: int = TREE_SIZE_CAP,
+    startup_grace_sec: float = 0.0,
+    total_job_stop_sec: float | None = TOTAL_JOB_STOP_SEC,
+    poll_interval_sec: float = 0.25,
+) -> int:
+    """Run supervised wrapper segments; return 0 complete, 3 job stop, 4 failure."""
+
+    if question_timeout_sec <= 0:
+        raise SupervisorError("question timeout must be positive")
+    if tree_size_cap <= 0:
+        raise SupervisorError("tree size cap must be positive")
+    if startup_grace_sec < 0:
+        raise SupervisorError("startup grace must be nonnegative")
+    if total_job_stop_sec is not None and total_job_stop_sec <= 0:
+        raise SupervisorError("total job stop must be positive")
+    if poll_interval_sec <= 0:
+        raise SupervisorError("poll interval must be positive")
+    _protected_launcher_args(launcher_args)
+
+    questions_path = questions_path.expanduser().resolve()
+    results_path = results_path.expanduser().resolve()
+    checkpoint = checkpoint.expanduser().resolve()
+    launcher = launcher.expanduser().resolve()
+    artifact_dir = artifact_dir.expanduser().resolve()
+    state_path = state_path.expanduser().resolve()
+    for path, label in ((questions_path, "questions"), (launcher, "launcher")):
+        if not path.is_file():
+            raise SupervisorError(f"{label} file does not exist: {path}")
+    if not checkpoint.exists():
+        raise SupervisorError(f"checkpoint does not exist: {checkpoint}")
+    if len({questions_path, results_path, state_path}) != 3:
+        raise SupervisorError("questions, results, and state paths must be distinct")
+
+    questions = _read_questions(questions_path)
+    question_artifact = _artifact(questions_path)
+    launcher_artifact = _artifact(launcher)
+    supervisor_artifact = _artifact(Path(__file__).resolve())
+    policy = {
+        "hard_question_timeout_sec": float(question_timeout_sec),
+        "cooperative_tree_size_cap": int(tree_size_cap),
+        "startup_grace_sec": float(startup_grace_sec),
+        "total_job_stop_sec": (
+            float(total_job_stop_sec) if total_job_stop_sec is not None else None
+        ),
+        "startup_accounting": (
+            "The first question clock begins when the wrapper manifest is first "
+            "observed, after launcher preflight and before model loading, so model "
+            "startup is counted. startup_grace_sec is added only to that first "
+            "question's allowance. Later clocks begin when the preceding JSONL "
+            "row is observed."
+        ),
+    }
+    results_path.parent.mkdir(parents=True, exist_ok=True)
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    prefix = _validate_prefix(results_path, questions, require_terminated=True)
+    invocation_id = uuid.uuid4().hex
+    prior_state: dict[str, Any] | None = None
+    if state_path.is_file():
+        prior_state = _artifact(state_path)
+        try:
+            previous = json.loads(state_path.read_text(encoding="utf-8"))
+            if isinstance(previous, dict):
+                prior_state["status"] = previous.get("status")
+                prior_state["invocation_id"] = previous.get("invocation_id")
+        except (OSError, json.JSONDecodeError):
+            prior_state["status"] = "unreadable"
+    state: dict[str, Any] = {
+        "schema_version": SCHEMA_VERSION,
+        "status": "preparing",
+        "created_utc": _utc_now(),
+        "invocation_id": invocation_id,
+        "recovered_from_result_prefix_rows": len(prefix),
+        "prior_state": prior_state,
+        "artifacts": {
+            "questions": question_artifact,
+            "launcher": launcher_artifact,
+            "supervisor": supervisor_artifact,
+            "results_path": str(results_path),
+            "artifact_dir": str(artifact_dir),
+        },
+        "checkpoint": str(checkpoint),
+        "launcher_args": list(launcher_args),
+        "policy": policy,
+        "attempts": [],
+    }
+    _write_json_atomic(state_path, state)
+
+    job_started = time.monotonic()
+    try:
+        if len(prefix) == len(questions):
+            state["status"] = "succeeded"
+            state["completed_utc"] = _utc_now()
+            state["result_rows"] = len(prefix)
+            state["artifacts"]["results"] = _artifact(results_path)
+            _write_json_atomic(state_path, state)
+            return 0
+
+        while len(prefix) < len(questions):
+            attempt_number = len(state["attempts"]) + 1
+            attempt_id = f"{invocation_id}-{attempt_number:04d}-{uuid.uuid4().hex}"
+            stem = f"attempt-{attempt_id}"
+            wrapper_manifest = artifact_dir / f"{stem}.wrapper-manifest.json"
+            stdout_path = artifact_dir / f"{stem}.stdout.log"
+            stderr_path = artifact_dir / f"{stem}.stderr.log"
+            attempt_manifest = artifact_dir / f"{stem}.supervisor.json"
+            command = _launcher_command(
+                launcher=launcher,
+                questions=questions_path,
+                results=results_path,
+                checkpoint=checkpoint,
+                wrapper_manifest=wrapper_manifest,
+                launcher_args=launcher_args,
+                resume=bool(prefix),
+                question_timeout_sec=question_timeout_sec,
+                tree_size_cap=tree_size_cap,
+            )
+            rows_before = len(prefix)
+            started_utc = _utc_now()
+            attempt_started = time.monotonic()
+            first_pending = True
+            # The wrapper writes its manifest after launcher preflight and
+            # before model loading.  Start the first question clock only then:
+            # preflight is excluded, while model startup is included.
+            current_started: float | None = None
+            termination = "unknown"
+            return_code: int | None = None
+            with stdout_path.open("xb") as stdout_stream, stderr_path.open("xb") as stderr_stream:
+                process = _popen_group(
+                    command,
+                    cwd=Path(__file__).resolve().parents[2],
+                    stdout=stdout_stream,
+                    stderr=stderr_stream,
+                )
+                while True:
+                    now = time.monotonic()
+                    if current_started is None and wrapper_manifest.is_file():
+                        current_started = now
+                    observed = _validate_prefix(
+                        results_path, questions, require_terminated=False
+                    )
+                    if len(observed) > len(prefix):
+                        prefix = observed
+                        current_started = now
+                        first_pending = False
+                        if len(prefix) == len(questions):
+                            # Let the wrapper finalize its own manifest cleanly.
+                            try:
+                                return_code = process.wait(timeout=30.0)
+                            except subprocess.TimeoutExpired:
+                                _kill_process_tree(process)
+                                return_code = process.returncode
+                            termination = (
+                                "complete" if return_code == 0 else "launcher_exit"
+                            )
+                            break
+
+                    return_code = process.poll()
+                    if return_code is not None:
+                        termination = "launcher_exit"
+                        break
+
+                    if total_job_stop_sec is not None and now - job_started >= total_job_stop_sec:
+                        _kill_process_tree(process)
+                        return_code = process.returncode
+                        termination = "total_job_stop"
+                        break
+
+                    allowance = question_timeout_sec + (
+                        startup_grace_sec if first_pending else 0.0
+                    )
+                    if (
+                        current_started is not None
+                        and now - current_started >= allowance
+                    ):
+                        _kill_process_tree(process)
+                        return_code = process.returncode
+                        # The row could have completed in the kill race. Re-read
+                        # before appending any synthetic result.
+                        observed = _validate_prefix(
+                            results_path, questions, require_terminated=True
+                        )
+                        if len(observed) == len(prefix):
+                            pending = questions[len(prefix)]
+                            timeout_execution_config = _timeout_execution_config(
+                                wrapper_manifest,
+                                invocation_id=invocation_id,
+                                attempt_id=attempt_id,
+                            )
+                            _append_row(
+                                results_path,
+                                _timeout_row(
+                                    pending,
+                                    timeout_sec=question_timeout_sec,
+                                    observed_wall_sec=now - current_started,
+                                    attempt_number=attempt_number,
+                                    execution_config=timeout_execution_config,
+                                    tree_size_cap=tree_size_cap,
+                                ),
+                            )
+                            prefix = _validate_prefix(
+                                results_path, questions, require_terminated=True
+                            )
+                            termination = "hard_question_timeout"
+                        else:
+                            prefix = observed
+                            termination = "timeout_completion_race"
+                        break
+                    time.sleep(poll_interval_sec)
+
+            ended_utc = _utc_now()
+            frozen_wrapper_manifest = (
+                _artifact(wrapper_manifest) if wrapper_manifest.is_file() else None
+            )
+            attempt_record = {
+                "schema_version": ATTEMPT_SCHEMA_VERSION,
+                "attempt_number": attempt_number,
+                "attempt_id": attempt_id,
+                "invocation_id": invocation_id,
+                "started_utc": started_utc,
+                "ended_utc": ended_utc,
+                "wall_time_sec": time.monotonic() - attempt_started,
+                "rows_before": rows_before,
+                "rows_after": len(prefix),
+                "termination": termination,
+                "return_code": return_code,
+                "command": command,
+                "wrapper_manifest": frozen_wrapper_manifest,
+                "wrapper_manifest_path": str(wrapper_manifest),
+                "stdout_log": _artifact(stdout_path),
+                "stderr_log": _artifact(stderr_path),
+            }
+            _write_json_exclusive(attempt_manifest, attempt_record)
+            attempt_summary = dict(attempt_record)
+            attempt_summary["attempt_manifest"] = _artifact(attempt_manifest)
+            state["attempts"].append(attempt_summary)
+            state["status"] = (
+                "running" if termination != "total_job_stop" else "job_stopped"
+            )
+            state["result_rows"] = len(prefix)
+            state["updated_utc"] = ended_utc
+            if results_path.is_file():
+                state["artifacts"]["partial_results"] = _artifact(results_path)
+            _write_json_atomic(state_path, state)
+            if termination == "total_job_stop":
+                return 3
+            if termination == "launcher_exit" and return_code != 0:
+                state["status"] = "failed"
+                state["failure"] = (
+                    f"launcher exited with code {return_code}; inspect immutable attempt logs"
+                )
+                _write_json_atomic(state_path, state)
+                return 4
+            if termination == "launcher_exit" and len(prefix) < len(questions):
+                state["status"] = "failed"
+                state["failure"] = "launcher exited successfully before producing all rows"
+                _write_json_atomic(state_path, state)
+                return 4
+
+        state["status"] = "succeeded"
+        state["completed_utc"] = _utc_now()
+        state["result_rows"] = len(prefix)
+        state["artifacts"].pop("partial_results", None)
+        state["artifacts"]["results"] = _artifact(results_path)
+        _write_json_atomic(state_path, state)
+        return 0
+    finally:
+        # This supervisor is deliberately lock-free. Exact-prefix validation and
+        # process-tree termination are its safety boundaries; callers must
+        # serialize supervisor invocations.
+        pass
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Run v12 search with an external hard 1000-second question cap."
+    )
+    parser.add_argument("--questions", type=Path, required=True)
+    parser.add_argument("--results", type=Path, required=True)
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--launcher", type=Path, default=DEFAULT_LAUNCHER)
+    parser.add_argument("--artifact-dir", type=Path)
+    parser.add_argument("--state", type=Path)
+    parser.add_argument("--startup-grace-sec", type=float, default=0.0)
+    parser.add_argument(
+        "--question-timeout-sec", type=float, default=QUESTION_TIMEOUT_SEC
+    )
+    parser.add_argument("--tree-size-cap", type=int, default=TREE_SIZE_CAP)
+    parser.add_argument(
+        "--total-job-stop-sec", type=float, default=TOTAL_JOB_STOP_SEC
+    )
+    parser.add_argument("--poll-interval-sec", type=float, default=0.25)
+    parser.add_argument(
+        "launcher_args",
+        nargs=argparse.REMAINDER,
+        help="Arguments passed to run_search_benchmark.py after a standalone --.",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    launcher_args = list(args.launcher_args)
+    if launcher_args[:1] == ["--"]:
+        launcher_args = launcher_args[1:]
+    results = args.results.expanduser().resolve()
+    artifact_dir = (
+        args.artifact_dir.expanduser().resolve()
+        if args.artifact_dir
+        else results.with_name(results.name + ".hard-supervisor-attempts")
+    )
+    state = (
+        args.state.expanduser().resolve()
+        if args.state
+        else results.with_name(results.name + ".hard-supervisor-state.json")
+    )
+    try:
+        return run_supervisor(
+            questions_path=args.questions,
+            results_path=results,
+            checkpoint=args.checkpoint,
+            launcher=args.launcher,
+            artifact_dir=artifact_dir,
+            state_path=state,
+            launcher_args=launcher_args,
+            question_timeout_sec=args.question_timeout_sec,
+            tree_size_cap=args.tree_size_cap,
+            startup_grace_sec=args.startup_grace_sec,
+            total_job_stop_sec=args.total_job_stop_sec,
+            poll_interval_sec=args.poll_interval_sec,
+        )
+    except SupervisorError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mce220_runner/grpo_pipeline/modules/llm_api_interface.py

@@ -0,0 +1,427 @@
+"""
+Local LLM interface for beam_search.
+
+This replaces the previous OpenRouter/API-based implementation.
+
+Public API:
+  - LLM(prompt, Gamma=None, M_current=None, k=5, adapter_path=None, use_dummy=False, **gen_kwargs) -> List[str]
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import hashlib
+from dataclasses import dataclass
+from typing import List, Optional, Any
+
+
+_MODEL_CACHE: dict[tuple[str, str], Any] = {}
+_DUMMY_CALL_IDX: int = 0
+_LAST_LLM_STATS: dict[str, Any] = {}
+
+
+def get_last_llm_stats(*, reset: bool = False) -> dict[str, Any]:
+    stats = dict(_LAST_LLM_STATS)
+    if reset:
+        _LAST_LLM_STATS.clear()
+    return stats
+
+
+def _strip_code_fences(text: str) -> str:
+    text = re.sub(r"^```[a-zA-Z0-9_-]*\s*", "", text.strip())
+    text = re.sub(r"\s*```$", "", text.strip())
+    return text.strip()
+
+
+def _extract_inequalities(text: str, k: int) -> List[str]:
+    """
+    Extract up to k candidate inequality strings from model output.
+    Accepts numbered lists, bullets, code fences, and JSON arrays.
+    """
+    text = _strip_code_fences(text)
+
+    # Try JSON first
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, list):
+            out = []
+            for x in obj:
+                if isinstance(x, str):
+                    s = x.strip()
+                    if s:
+                        out.append(s)
+            if out:
+                return out[:k]
+    except Exception:
+        pass
+
+    # Otherwise parse lines
+    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+    cands: List[str] = []
+    for ln in lines:
+        # remove common list prefixes: "1.", "1)", "*", and "-" ONLY if followed by space (bullet point)
+        # We must NOT strip a leading "-" if it's followed by a digit or "H("/"I(", as it's likely a negative coefficient.
+        ln = re.sub(r"^\s*(?:[*]|(\d+)[\.\)]|-(?:\s+|$))\s*", "", ln).strip()
+        ln = ln.strip("`").strip()
+        if not ln:
+            continue
+
+        # keep only plausible math constraints or explicit "wrong" signal
+        if ("H(" in ln) or ("I(" in ln):
+            cands.append(ln)
+        elif "wrong" in ln.lower():
+            cands.append("wrong")
+
+        if len(cands) >= k:
+            break
+
+    return cands[:k]
+
+
+def _read_base_model_from_adapter(adapter_path: str) -> Optional[str]:
+    cfg_path = os.path.join(adapter_path, "adapter_config.json")
+    try:
+        with open(cfg_path, "r", encoding="utf-8") as f:
+            cfg = json.load(f)
+        base = cfg.get("base_model_name_or_path")
+        return base if isinstance(base, str) and base else None
+    except Exception:
+        return None
+
+
+def _load_tokenizer_compat(tokenizer_src: str):
+    from transformers import AutoTokenizer
+
+    extra_kwargs = {}
+    cfg_path = os.path.join(tokenizer_src, "tokenizer_config.json")
+    if os.path.isdir(tokenizer_src) and os.path.exists(cfg_path):
+        try:
+            with open(cfg_path, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            if isinstance(cfg.get("extra_special_tokens"), list):
+                sys.stderr.write(
+                    f"[llm] Sanitizing tokenizer extra_special_tokens for: {tokenizer_src}\n"
+                )
+                extra_kwargs["extra_special_tokens"] = {}
+        except Exception:
+            pass
+
+    return AutoTokenizer.from_pretrained(
+        tokenizer_src,
+        trust_remote_code=True,
+        **extra_kwargs,
+    )
+
+
+def _load_local_model(
+    adapter_path: Optional[str] = None,
+    *,
+    base_model: Optional[str] = None,
+    device_map: str = "auto",
+):
+    """
+    Load HF base model, optionally with a PEFT adapter.
+    Caches model/tokenizer to avoid re-loading each call.
+    """
+    from transformers import AutoTokenizer, AutoModelForCausalLM
+    import torch
+
+    # Only treat as adapter if path is truthy AND contains adapter_config.json
+    adapter_abs = ""
+    if adapter_path and adapter_path.strip():
+        abs_p = os.path.abspath(adapter_path.strip())
+        if os.path.exists(os.path.join(abs_p, "adapter_config.json")):
+            adapter_abs = abs_p
+        else:
+            sys.stderr.write(f"[llm] Warning: adapter_path '{adapter_path}' provided but no adapter_config.json found in {abs_p}. Ignoring adapter.\n")
+
+    resolved_base = (
+        base_model
+        or os.environ.get("QWEN_BASE_MODEL")
+        or (_read_base_model_from_adapter(adapter_abs) if adapter_abs else None)
+        or "Qwen/Qwen3-0.6B"
+    )
+
+    weights_path = os.environ.get("QWEN_WEIGHTS_PATH", "").strip()
+    cache_key = (adapter_abs, resolved_base, weights_path)
+    if cache_key in _MODEL_CACHE:
+        return _MODEL_CACHE[cache_key]
+
+    if weights_path:
+        from safetensors.torch import load_file
+        sys.stderr.write(f"[llm] Loading base arch from: {resolved_base}\n")
+        sys.stderr.write(f"[llm] Overriding weights from: {weights_path}\n")
+        sys.stderr.flush()
+        tokenizer = _load_tokenizer_compat(resolved_base)
+        model = AutoModelForCausalLM.from_pretrained(
+            resolved_base,
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else "auto",
+            device_map=device_map,
+            trust_remote_code=True,
+        )
+        ckpt = load_file(os.path.join(weights_path, "model.safetensors"), device="cpu")
+        # The in-memory model state_dict includes lm_head.weight (tied to embed_tokens.weight).
+        # The GRPO checkpoint also has lm_head.weight serialized by DeepSpeed — load all keys.
+        model.load_state_dict(ckpt, strict=True)
+        model.eval()
+        _MODEL_CACHE[cache_key] = (model, tokenizer)
+        return model, tokenizer
+
+    if adapter_abs:
+        sys.stderr.write(f"[llm] Loading model: {resolved_base}\n")
+        sys.stderr.write(f"[llm] Loading adapter: {adapter_abs}\n")
+    else:
+        sys.stderr.write(f"[llm] Loading base model only: {resolved_base}\n")
+    sys.stderr.flush()
+
+    # Tokenizer should come from the adapter if present (it might include special tokens),
+    # otherwise from the base model.
+    tok_src = adapter_abs or resolved_base
+    tokenizer = _load_tokenizer_compat(tok_src)
+    model = AutoModelForCausalLM.from_pretrained(
+        resolved_base,
+        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else "auto",
+        device_map=device_map,
+        trust_remote_code=True,
+    )
+
+    if adapter_abs:
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, adapter_abs)
+
+    model.eval()
+
+    _MODEL_CACHE[cache_key] = (model, tokenizer)
+    return model, tokenizer
+
+
+def _build_alpaca_prompt(input_text: str) -> str:
+    # Mirror the exact formatting observed in ft_using_Axolotl_1/last_run_prepared/* decoding
+    instruction = "You are proving the entropy inequality. Follow the instructions carefully."
+    preamble = (
+        "Below is an instruction that describes a task, paired with an input that provides further context. "
+        "Write a response that appropriately completes the request."
+    )
+    return (
+        f"{preamble}\n\n"
+        f"### Instruction:\n{instruction}\n\n"
+        f"### Input:\n{input_text}\n\n\n\n"
+        f"### Response:\n"
+    )
+
+
+def LLM(
+    prompt: str,
+    Gamma=None,  # kept for backward compatibility (ignored for local inference)
+    M_current=None,  # kept for backward compatibility (ignored for local inference)
+    k: int = 5,
+    adapter_path: Optional[str] = None,
+    use_dummy: bool = False,
+    **gen_kwargs,
+) -> List[str]:
+    """
+    Local inference to propose inequalities.
+
+    Args:
+      prompt: natural language prompt
+      k: number of inequalities requested
+      adapter_path: local path to PEFT adapter directory (required unless use_dummy=True)
+      use_dummy: if True, returns a small hardcoded set for testing
+      gen_kwargs: passed to model.generate (e.g. max_new_tokens, temperature)
+    """
+    global _LAST_LLM_STATS
+
+    if use_dummy:
+        # Dummy mode should still generate *varied* valid inequalities; otherwise tree_search
+        # will keep adding the same single inequality and will never be able to prove even
+        # simple Shannon-type targets.
+        #
+        # We deterministically vary outputs based on the prompt content so different nodes
+        # (with different CURRENT INEQUALITIES M) receive different proposals.
+        def _parse_n_from_prompt(p: str) -> int:
+            # Try old format first
+            m = re.search(r"NUMBER OF VARIABLES:\s*\n(\d+)\b", p)
+            if m:
+                try:
+                    return max(1, int(m.group(1)))
+                except Exception:
+                    pass
+            
+            # Fallback: Extract max index from X_{...}
+            idxs = []
+            for inside in re.findall(r"X_\{([^}]+)\}", p):
+                parts = [part.strip() for part in inside.split(",") if part.strip()]
+                for part in parts:
+                    if part.isdigit():
+                        idxs.append(int(part))
+            if idxs:
+                return max(idxs)
+            return 3
+
+        def _parse_allowed_range_from_prompt(p: str) -> Optional[tuple[int, int]]:
+            # Matches: "range 4..8" in IMPORTANT CONSTRAINT section.
+            m = re.search(r"range\s+(\d+)\.\.(\d+)", p)
+            if m:
+                try:
+                    lo = int(m.group(1))
+                    hi = int(m.group(2))
+                    if lo > hi:
+                        lo, hi = hi, lo
+                    return lo, hi
+                except Exception:
+                    pass
+            
+            # Fallback: return (1, n)
+            return None
+
+        def _dummy_pool(n: int, lo: int, hi: int) -> List[str]:
+            cands: List[str] = []
+            lo = max(1, int(lo))
+            hi = min(int(n), int(hi))
+            if lo > hi:
+                lo, hi = 1, int(n)
+            vars_list = list(range(lo, hi + 1))
+            # Non-negativity
+            for i in vars_list:
+                cands.append(f"H(X_{{{i}}})>=0")
+            # Mutual information (unconditional)
+            for ii, i in enumerate(vars_list):
+                for j in vars_list[ii + 1 :]:
+                    cands.append(f"I(X_{{{i}}};X_{{{j}}})>=0")
+            # Conditional mutual information with a single conditioning variable
+            if len(vars_list) >= 3:
+                for ii, i in enumerate(vars_list):
+                    for j in vars_list[ii + 1 :]:
+                        for c in vars_list:
+                            if c != i and c != j:
+                                cands.append(f"I(X_{{{i}}};X_{{{j}}}|X_{{{c}}})>=0")
+            # Conditional entropy with a single conditioning variable
+            for i in vars_list:
+                for j in vars_list:
+                    if j != i:
+                        cands.append(f"H(X_{{{i}}}|X_{{{j}}})>=0")
+            return cands
+
+        global _DUMMY_CALL_IDX
+        _DUMMY_CALL_IDX += 1
+
+        n = _parse_n_from_prompt(prompt)
+        rng = _parse_allowed_range_from_prompt(prompt) or (1, n)
+        pool = _dummy_pool(n, rng[0], rng[1])
+        # Stable seed from prompt content + call index, so repeated calls with the same
+        # prompt still yield different proposals (needed for rollout diversity).
+        seed_material = f"{prompt}\n[DUMMY_CALL_IDX]={_DUMMY_CALL_IDX}".encode("utf-8")
+        seed = int.from_bytes(hashlib.md5(seed_material).digest()[:8], "big", signed=False)
+        import random
+
+        rng = random.Random(seed)
+        rng.shuffle(pool)
+        out = pool[: max(0, int(k))]
+        if os.environ.get("QWEN_PRINT_OUTPUT", "0") == "1":
+            target_match = re.search(r"TARGET:\s*\n(.*?)\n\n", prompt, re.DOTALL)
+            target_val = target_match.group(1).strip() if target_match else "unknown"
+            sys.stderr.write(f"[llm] Target: {target_val}\n")
+            sys.stderr.write(f"  Dummy Extracted: {out}\n")
+            sys.stderr.flush()
+        _LAST_LLM_STATS = {
+            "prompt_tokens": 0,
+            "generated_tokens_total": 0,
+            "generated_tokens_per_sequence": [0 for _ in out],
+            "num_sequences": len(out),
+            "extracted_candidates": len(out),
+        }
+        return out
+
+    # Use raw prompt when requested (matches alphabet SFT format).
+    if os.environ.get("QWEN_RAW_PROMPT", "0") == "1":
+        constrained_prompt = prompt
+    else:
+        # Fully adapt to the SFT training format: Alpaca template + caller-provided input block.
+        constrained_prompt = _build_alpaca_prompt(prompt.strip())
+    if os.environ.get("QWEN_PRINT_PROMPT", "0") == "1":
+        sys.stderr.write("[llm] Full prompt:\n")
+        sys.stderr.write(constrained_prompt)
+        sys.stderr.write("\n")
+        sys.stderr.flush()
+
+    # If adapter_path is omitted, we fall back to the baseline model (no PEFT).
+    model, tokenizer = _load_local_model(adapter_path=adapter_path)
+
+    import torch
+
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    inputs = tokenizer(constrained_prompt, return_tensors="pt")
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+    # Print prompt tokens alongside prompt for debugging alignment
+
+    default_kwargs = dict(
+        max_new_tokens=int(os.environ.get("QWEN_MAX_NEW_TOKENS", "512")),
+        # max_time=float(os.environ.get("QWEN_MAX_TIME", "40")),
+        do_sample=True,
+        temperature=float(os.environ.get("QWEN_TEMPERATURE", "0.7")),
+        top_p=float(os.environ.get("QWEN_TOP_P", "0.9")),
+        repetition_penalty=1.05,
+        pad_token_id=tokenizer.eos_token_id,
+        eos_token_id=tokenizer.eos_token_id,
+    )
+    default_kwargs.update(gen_kwargs or {})
+
+    with torch.inference_mode():
+        out = model.generate(
+            input_ids=inputs["input_ids"],
+            attention_mask=inputs.get("attention_mask", None),
+            **default_kwargs,
+        )
+
+    # Decode only the newly generated part when possible.
+    # If num_return_sequences > 1, generate() returns multiple sequences.
+    prompt_len = inputs["input_ids"].shape[-1]
+    cands: List[str] = []
+    decoded_texts: List[str] = []
+    
+    if hasattr(out, "shape") and len(out.shape) >= 2 and out.shape[0] > 1:
+        # One inequality per returned sequence (preferred for "GPU batch generation")
+        generated_token_lengths: List[int] = []
+        for i in range(out.shape[0]):
+            gen_ids = out[i][prompt_len:]
+            generated_token_lengths.append(int(gen_ids.shape[-1]))
+            text_i = tokenizer.decode(gen_ids, skip_special_tokens=True).strip()
+            decoded_texts.append(text_i)
+            one = _extract_inequalities(text_i, k=1)
+            if one:
+                cands.append(one[0])
+            if len(cands) >= k:
+                # Keep decoding for printing if needed, but we have enough candidates
+                pass 
+    else:
+        gen_ids = out[0][prompt_len:]
+        generated_token_lengths = [int(gen_ids.shape[-1])]
+        text = tokenizer.decode(gen_ids, skip_special_tokens=True).strip()
+        decoded_texts.append(text)
+        cands = _extract_inequalities(text, k=k)
+
+    _LAST_LLM_STATS = {
+        "prompt_tokens": int(prompt_len),
+        "generated_tokens_total": int(sum(generated_token_lengths)),
+        "generated_tokens_per_sequence": generated_token_lengths,
+        "num_sequences": len(generated_token_lengths),
+        "extracted_candidates": len(cands),
+    }
+
+    if os.environ.get("QWEN_PRINT_OUTPUT", "0") == "1":
+        # Simplified printing: only target, generated, and extracted.
+        target_match = re.search(r"TARGET:\s*\n(.*?)\n\n", prompt, re.DOTALL)
+        target_val = target_match.group(1).strip() if target_match else "unknown"
+        sys.stderr.write(f"[llm] Target: {target_val}\n")
+        for i, txt in enumerate(decoded_texts):
+            # Only print first line of generated text if it's long? No, user said generated inequality.
+            # Usually model outputs just the inequality.
+            sys.stderr.write(f"  Gen {i}: {txt}\n")
+        sys.stderr.write(f"  Extracted: {cands}\n")
+        sys.stderr.flush()
+    return cands

mce220_runner/requirements.txt

@@ -0,0 +1,10 @@
+# Install a CUDA-enabled PyTorch wheel suitable for the host before this file if needed.
+torch==2.3.1
+transformers==4.55.2
+peft==0.17.0
+accelerate==1.10.0
+huggingface_hub==0.36.2
+safetensors==0.4.3
+numpy==1.26.4
+scipy==1.13.1
+sympy==1.12.1

mce220_runner/run_mce220.sh

@@ -0,0 +1,182 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage: run_mce220.sh {dry-run|smoke|full} [--gpu-ids LIST] [--workers N] [--output-dir DIR]
+
+Modes:
+  dry-run  Verify all downloaded assets and print the frozen 220-row command.
+  smoke    Evaluate the first question with one GPU and reduced search settings.
+  full     Evaluate all 220 questions under the hard-timeout supervisor.
+EOF
+}
+
+if [[ $# -lt 1 ]]; then
+  usage >&2
+  exit 2
+fi
+
+MODE="$1"
+shift
+case "$MODE" in
+  dry-run|smoke|full) ;;
+  *) usage >&2; exit 2 ;;
+esac
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+PYTHON_BIN="${PYTHON:-python3}"
+ASSET_DIR="${MCE220_ASSET_DIR:-$SCRIPT_DIR/assets}"
+GPU_IDS="0,1,2,3,4,5,6,7"
+WORKERS=""
+OUTPUT_DIR=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --gpu-ids)
+      [[ $# -ge 2 ]] || { echo "missing value for --gpu-ids" >&2; exit 2; }
+      GPU_IDS="$2"; shift 2 ;;
+    --workers)
+      [[ $# -ge 2 ]] || { echo "missing value for --workers" >&2; exit 2; }
+      WORKERS="$2"; shift 2 ;;
+    --output-dir)
+      [[ $# -ge 2 ]] || { echo "missing value for --output-dir" >&2; exit 2; }
+      OUTPUT_DIR="$2"; shift 2 ;;
+    -h|--help)
+      usage; exit 0 ;;
+    *) echo "unknown option: $1" >&2; usage >&2; exit 2 ;;
+  esac
+done
+
+if [[ -z "$WORKERS" ]]; then
+  if [[ "$MODE" == "smoke" ]]; then WORKERS=1; else WORKERS=8; fi
+fi
+[[ "$WORKERS" =~ ^[1-9][0-9]*$ ]] || {
+  echo "--workers must be a positive integer" >&2
+  exit 2
+}
+if [[ "$MODE" == "smoke" && "$WORKERS" != "1" ]]; then
+  echo "smoke mode is intentionally restricted to --workers 1" >&2
+  exit 2
+fi
+
+if [[ -z "$OUTPUT_DIR" ]]; then
+  OUTPUT_DIR="$SCRIPT_DIR/runs/$MODE"
+fi
+mkdir -p -- "$OUTPUT_DIR"
+
+QUESTIONS="$SCRIPT_DIR/dataset/data/questions.jsonl"
+CHECKPOINT="$ASSET_DIR/model-repo/qwen-06b-sft-4type-old-format-lora-dataset-a-4096-balanced-higher-maxm/checkpoint-9534"
+BASE_MODEL="$ASSET_DIR/qwen3-0.6b"
+RUNNER="$SCRIPT_DIR/beam_search_model2/run_on_window_shear_jsonl_v12.py"
+WRAPPER="$SCRIPT_DIR/experiments/reviewer_response/run_search_benchmark.py"
+SUPERVISOR="$SCRIPT_DIR/experiments/reviewer_response/supervise_search_benchmark.py"
+
+"$PYTHON_BIN" "$SCRIPT_DIR/download_assets.py" \
+  --asset-dir "$ASSET_DIR" \
+  --verify-only
+
+common_full_args=(
+  --questions "$QUESTIONS"
+  --checkpoint "$CHECKPOINT"
+  --base-model "$BASE_MODEL"
+  --runner "$RUNNER"
+  --gpu-ids "$GPU_IDS"
+  --workers "$WORKERS"
+  --beam-size 32
+  --rollouts 6
+  --max-depth 24
+  --seed 42
+  --temperature 1.2
+  --max-new-tokens 2048
+  --generation-max-time 20
+  --max-vars-for-lp 0
+  --lp-workers "$WORKERS"
+  --min-n 10
+  --max-n 20
+  --prompt-format canonical
+  --normalize-candidates
+  --raw-prompt
+  --print-llm
+)
+
+case "$MODE" in
+  dry-run)
+    stamp="$(date -u +%Y%m%dT%H%M%SZ)-$$"
+    "$PYTHON_BIN" "$WRAPPER" \
+      "${common_full_args[@]}" \
+      --results "$OUTPUT_DIR/mce220-dry-run-results.jsonl" \
+      --manifest "$OUTPUT_DIR/mce220-dry-run-$stamp.manifest.json" \
+      --sample-max-time-sec 1000 \
+      --hard-question-timeout-sec 1000 \
+      --sample-max-tree-size 6000 \
+      --dry-run
+    ;;
+  smoke)
+    first_gpu="${GPU_IDS%%,*}"
+    smoke_questions="$OUTPUT_DIR/smoke-question.jsonl"
+    head -n 1 -- "$QUESTIONS" > "$smoke_questions"
+    smoke_results="$OUTPUT_DIR/smoke-results.jsonl"
+    resume_args=()
+    [[ -s "$smoke_results" ]] && resume_args+=(--resume)
+    "$PYTHON_BIN" "$WRAPPER" \
+      --questions "$smoke_questions" \
+      --results "$smoke_results" \
+      --checkpoint "$CHECKPOINT" \
+      --base-model "$BASE_MODEL" \
+      --runner "$RUNNER" \
+      --gpu-ids "$first_gpu" \
+      --workers 1 \
+      --beam-size 4 \
+      --rollouts 1 \
+      --max-depth 4 \
+      --seed 42 \
+      --temperature 1.2 \
+      --max-new-tokens 512 \
+      --generation-max-time 20 \
+      --sample-max-time-sec 300 \
+      --sample-max-tree-size 256 \
+      --max-vars-for-lp 0 \
+      --lp-workers 1 \
+      --min-n 10 \
+      --max-n 20 \
+      --prompt-format canonical \
+      --normalize-candidates \
+      --raw-prompt \
+      --print-llm \
+      "${resume_args[@]}"
+    ;;
+  full)
+    "$PYTHON_BIN" "$SUPERVISOR" \
+      --questions "$QUESTIONS" \
+      --results "$OUTPUT_DIR/results.jsonl" \
+      --checkpoint "$CHECKPOINT" \
+      --launcher "$WRAPPER" \
+      --artifact-dir "$OUTPUT_DIR/supervisor-attempts" \
+      --state "$OUTPUT_DIR/supervisor-state.json" \
+      --question-timeout-sec 1000 \
+      --tree-size-cap 6000 \
+      --total-job-stop-sec 151200 \
+      --poll-interval-sec 0.25 \
+      -- \
+      --base-model "$BASE_MODEL" \
+      --runner "$RUNNER" \
+      --gpu-ids "$GPU_IDS" \
+      --workers "$WORKERS" \
+      --beam-size 32 \
+      --rollouts 6 \
+      --max-depth 24 \
+      --seed 42 \
+      --temperature 1.2 \
+      --max-new-tokens 2048 \
+      --generation-max-time 20 \
+      --max-vars-for-lp 0 \
+      --lp-workers "$WORKERS" \
+      --min-n 10 \
+      --max-n 20 \
+      --prompt-format canonical \
+      --normalize-candidates \
+      --raw-prompt \
+      --print-llm
+    ;;
+esac