gpt-5.6-sol

{
  "input": "const r = await tools.write_stdin({session_id:24753,chars:\"\",yield_time_ms:30000,max_output_tokens:2000});\ntext(JSON.stringify(r));\n"
}

{
  "cell_id": "138",
  "yield_time_ms": 30000,
  "max_tokens": 2000
}

{
  "input": "const r = await tools.write_stdin({session_id:24753,chars:\"\",yield_time_ms:30000,max_output_tokens:2000});\ntext(JSON.stringify(r));\n"
}

{
  "cell_id": "139",
  "yield_time_ms": 30000,
  "max_tokens": 2000
}

{
  "input": "const r = await tools.exec_command({cmd:\"python score_alpha.py --alpha .4 && python score_alpha.py --alpha .6 && python build_candidate.py --weight 3 --ratio-file /tmp/ratio_alpha0.4.npy --name alpha04 && python build_candidate.py --weight 3 --ratio-file /tmp/ratio_alpha0.6.npy --name alpha06\",workdir:\"/workspace\",yield_time_ms:30000,max_output_tokens:2000});\ntext(r.output);\n"
}

{
  "cell_id": "140",
  "yield_time_ms": 30000,
  "max_tokens": 2000
}

{
  "input": "const r = await tools.exec_command({cmd:\"python train_nano.py --train_npy /tmp/alpha04.npy --heldout_npy data/multi_dev.npy --out_json /tmp/alpha04_result.json\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:1000});\ntext(JSON.stringify(r));\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Update File: /workspace/submission/curate.py\\n@@\\n-\\\"\\\"\\\"Rank raw web documents by prose quality and balanced target-domain utility.\\n+\\\"\\\"\\\"Rank raw web documents by quality and target-relative distributional utility.\\n \\n-The criterion is intentionally label-free.  Each document receives a transparent\\n-quality score (English function-word density, sentence/paragraph structure,\\n-length, and penalties for boilerplate, corruption, repetition, and markup), and\\n-is assigned to one of four target registers using lexical/format cues.  The\\n-output interleaves ranked register queues to keep the prefix approximately\\n-token-balanced; a quality-ranked tail guarantees more than enough coverage.\\n+Each document receives a transparent prose-quality score plus a smoothed\\n+Moore--Lewis score: mean GPT-2-token log probability under one quarter of the\\n+disclosed target minus mean log probability under the raw pool.  Four ranked\\n+queues correspond to the four equal target registers.  Their exact BPE token\\n+budgets are interleaved, so every prefix remains balanced.  No document labels,\\n+external model, web access, or hand-picked IDs are used.\\n \\\"\\\"\\\"\\n@@\\n import math\\n import re\\n-from collections import Counter\\n from pathlib import Path\\n+import tempfile\\n+\\n+import numpy as np\\n+from transformers import AutoTokenizer\\n@@\\n TARGET_EST_TOKENS = 14_000_000  # margin above the evaluator's exact 12M BPE budget\\n+RANKED_PREFIX_TOKENS = 12_500_000\\n+RELEVANCE_WEIGHT = 3.0\\n+SMOOTHING = 0.25\\n+QUALITY_FLOOR = -2.0\\n@@\\n-def curate(pool_path):\\n-    queues = {k: [] for k in TARGET_SHARE}\\n-    all_scored = []\\n-    with open(pool_path, encoding=\\\"utf-8\\\") as f:\\n-        for line in f:\\n-            row = json.loads(line)\\n-            score, register, est = document_features(row[\\\"text\\\"])\\n-            item = (score, -row[\\\"id\\\"], row[\\\"id\\\"], est)\\n-            queues[register].append(item)\\n-            all_scored.append(item)\\n-\\n-    for q in queues.values():\\n-        q.sort(reverse=True)\\n-\\n-    # Greedily draw from the most under-filled target register. This makes every\\n-    # long prefix balanced, including the exact-BPE cutoff used by training.\\n-    pos = {k: 0 for k in queues}\\n-    used_est = {k: 0 for k in queues}\\n-    selected = []\\n-    selected_set = set()\\n-    while sum(used_est.values()) < TARGET_EST_TOKENS:\\n-        choices = [k for k in queues if pos[k] < len(queues[k])]\\n-        if not choices:\\n-            break\\n-        register = min(choices, key=lambda k: used_est[k] / TARGET_SHARE[k])\\n-        score, _, doc_id, est = queues[register][pos[register]]\\n-        pos[register] += 1\\n-        if score < -20:  # only empty/unusable records reach this guard\\n-            continue\\n-        selected.append(doc_id)\\n-        selected_set.add(doc_id)\\n-        used_est[register] += est\\n-\\n-    # Deterministic, quality-ranked reserve. IDs beyond 12M are ignored, but this\\n-    # ensures validity even when the character-to-BPE estimate is conservative.\\n-    all_scored.sort(reverse=True)\\n-    selected.extend(item[2] for item in all_scored if item[2] not in selected_set)\\n-    return selected, used_est, {k: len(v) for k, v in queues.items()}\\n+def robust_z(values):\\n+    \\\"\\\"\\\"Median/IQR scaling prevents a few corrupt pages dominating the score.\\\"\\\"\\\"\\n+    median = np.median(values)\\n+    scale = np.quantile(values, 0.75) - np.quantile(values, 0.25)\\n+    return np.clip((values - median) / max(float(scale), 1e-8), -5.0, 5.0)\\n+\\n+\\n+def curate(pool_path, dev_path):\\n+    \\\"\\\"\\\"Tokenize once, score against pool and four dev registers, then interleave.\\\"\\\"\\\"\\n+    tokenizer = AutoTokenizer.from_pretrained(\\\"gpt2\\\", local_files_only=True)\\n+    tokenizer.model_max_length = 10**30\\n+    eos, vocab = tokenizer.eos_token_id, tokenizer.vocab_size\\n+\\n+    with tempfile.TemporaryDirectory(prefix=\\\"curate-\\\") as tmp:\\n+        token_path = Path(tmp) / \\\"pool.uint16\\\"\\n+        offsets = [0]\\n+        qualities = []\\n+        background = np.zeros(vocab, dtype=np.int64)\\n+\\n+        # Batching invokes the Rust tokenizer efficiently. The temporary flat\\n+        # token store avoids retaining 200M Python integers in memory.\\n+        with open(token_path, \\\"wb\\\") as token_file, open(pool_path, encoding=\\\"utf-8\\\") as src:\\n+            batch_ids, batch_text = [], []\\n+\\n+            def flush_batch():\\n+                if not batch_text:\\n+                    return\\n+                encoded = tokenizer(batch_text, add_special_tokens=False).input_ids\\n+                arrays = []\\n+                for doc_id, text, ids in zip(batch_ids, batch_text, encoded):\\n+                    if doc_id != len(offsets) - 1:\\n+                        raise ValueError(\\\"pool ids must be unique, contiguous, and zero-based\\\")\\n+                    quality, _, _ = document_features(text)\\n+                    qualities.append(quality)\\n+                    arr = np.asarray(ids + [eos], dtype=np.uint16)\\n+                    arr.tofile(token_file)\\n+                    arrays.append(arr)\\n+                    offsets.append(offsets[-1] + len(arr))\\n+                background[:] += np.bincount(np.concatenate(arrays), minlength=vocab)\\n+                batch_ids.clear()\\n+                batch_text.clear()\\n+\\n+            for line in src:\\n+                row = json.loads(line)\\n+                batch_ids.append(row[\\\"id\\\"])\\n+                batch_text.append(row[\\\"text\\\"])\\n+                if len(batch_text) == 256:\\n+                    flush_batch()\\n+            flush_batch()\\n+\\n+        offsets = np.asarray(offsets, dtype=np.int64)\\n+        quality = np.asarray(qualities, dtype=np.float64)\\n+        n_docs = len(quality)\\n+        flat = np.memmap(token_path, dtype=np.uint16, mode=\\\"r\\\")\\n+\\n+        target = np.load(dev_path).astype(np.int64)\\n+        if len(target) % 4:\\n+            raise ValueError(\\\"disclosed target must contain four equal contiguous registers\\\")\\n+        quarter = len(target) // 4\\n+        alpha = SMOOTHING\\n+        bg_logp = np.log((background + alpha) / (background.sum() + alpha * vocab))\\n+        log_ratios = []\\n+        for q in range(4):\\n+            counts = np.bincount(target[q * quarter:(q + 1) * quarter], minlength=vocab)\\n+            target_logp = np.log((counts + alpha) / (counts.sum() + alpha * vocab))\\n+            log_ratios.append(target_logp - bg_logp)\\n+        log_ratios = np.asarray(log_ratios)\\n+\\n+        relevance = np.empty((4, n_docs), dtype=np.float32)\\n+        for doc_id in range(n_docs):\\n+            # Exclude only the separator added above; naturally occurring EOS\\n+            # markers remain part of the document and therefore of its score.\\n+            ids = np.asarray(flat[offsets[doc_id]:offsets[doc_id + 1] - 1], dtype=np.int64)\\n+            if len(ids):\\n+                relevance[:, doc_id] = log_ratios[:, ids].mean(axis=1)\\n+            else:\\n+                relevance[:, doc_id] = -99.0\\n+\\n+        quality_z = robust_z(quality)\\n+        scores = np.asarray([\\n+            quality_z + RELEVANCE_WEIGHT * robust_z(relevance[q].astype(np.float64))\\n+            for q in range(4)\\n+        ])\\n+        orders = [np.argsort(-scores[q], kind=\\\"stable\\\") for q in range(4)]\\n+        lengths = np.diff(offsets)\\n+        positions = np.zeros(4, dtype=np.int64)\\n+        register_tokens = np.zeros(4, dtype=np.int64)\\n+        used = np.zeros(n_docs, dtype=bool)\\n+        selected = []\\n+\\n+        while register_tokens.sum() < RANKED_PREFIX_TOKENS:\\n+            q = int(np.argmin(register_tokens))\\n+            while positions[q] < n_docs and used[orders[q][positions[q]]]:\\n+                positions[q] += 1\\n+            if positions[q] == n_docs:\\n+                break\\n+            doc_id = int(orders[q][positions[q]])\\n+            positions[q] += 1\\n+            if quality[doc_id] < QUALITY_FLOOR:\\n+                continue\\n+            used[doc_id] = True\\n+            selected.append(doc_id)\\n+            register_tokens[q] += lengths[doc_id]\\n+\\n+        # A deterministic reserve makes the file safely exceed 12M tokens. It is\\n+        # never reached in the normal official cutoff but guarantees validity.\\n+        reserve = np.argsort(-scores.max(axis=0), kind=\\\"stable\\\")\\n+        selected.extend(int(i) for i in reserve if not used[i])\\n+        return selected, register_tokens.tolist(), n_docs\\n@@\\n     ap = argparse.ArgumentParser()\\n     ap.add_argument(\\\"--pool\\\", default=\\\"/workspace/data/pool.jsonl\\\")\\n+    ap.add_argument(\\\"--dev\\\", default=\\\"/workspace/data/multi_dev.npy\\\")\\n     ap.add_argument(\\\"--output\\\", default=\\\"/workspace/submission/selection.json\\\")\\n     args = ap.parse_args()\\n-    selection, estimates, counts = curate(args.pool)\\n+    selection, register_tokens, n_docs = curate(args.pool, args.dev)\\n@@\\n     with open(args.output, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n         json.dump(selection, f)\\n     print(f\\\"wrote {len(selection)} unique ids to {args.output}\\\")\\n-    print(\\\"estimated prefix tokens by register:\\\", estimates)\\n-    print(\\\"pool documents by assigned register:\\\", counts)\\n+    print(\\\"ranked-prefix exact BPE tokens by target register:\\\", register_tokens)\\n+    print(\\\"pool documents scored:\\\", n_docs)\\n*** End Patch\";\ntext(await tools.apply_patch(patch));\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:77352,chars:\"\",yield_time_ms:30000,max_output_tokens:2000});\ntext(JSON.stringify(r));\n"
}

{
  "cell_id": "143",
  "yield_time_ms": 30000,
  "max_tokens": 2000
}

{
  "input": "const r = await tools.exec_command({cmd:\"python train_nano.py --train_npy /tmp/r3o05.npy --heldout_npy data/multi_dev.npy --out_json /tmp/r3o05_result.json\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:1000});\ntext(JSON.stringify(r));\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"python submission/curate.py\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:3000});\ntext(JSON.stringify(r));\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Add File: /workspace/claim.md\\n+# Hypothesis\\n+\\n+Under a 12M-token constraint, a small GPT benefits more from coherent documents whose GPT-2 token distribution is characteristic of the disclosed high-quality target than from either random web text or quality filtering alone. Equal token allocation across the four target registers should prevent an easy, abundant register such as news from crowding out technical or encyclopedic text.\\n+\\n+# Mechanism\\n+\\n+`curate.py` combines a document-local prose score with a smoothed Moore–Lewis score, `mean(log p_target(token) - log p_pool(token))`. It forms one queue from each contiguous quarter of the disclosed target and interleaves the queues by exact GPT-2 token count. The predicted observable, independent of final perplexity, is therefore a roughly 3M-token contribution from each queue at the 12M cutoff, a higher average target-versus-pool log ratio than an uncurated sample, fewer boilerplate/corrupt pages, and lower unigram divergence from the disclosed target. In the development analysis, target-to-train unigram KL fell from 0.617 for the clean early slice to 0.332 for the chosen prefix.\\n+\\n+# Falsification\\n+\\n+The mechanism is falsified if regenerating the selection does not yield unique in-range IDs and balanced queue token counts, or if its prefix fails to improve target-relative log ratio, boilerplate rate, and target unigram divergence over an uncurated control. More decisively, it is falsified if repeated frozen-recipe evaluations on disjoint target samples do not beat both random selection and quality-only selection; that would show that the distributional proxy is overfitting the disclosed sample rather than identifying transferable register.\\n+\\n+# Transfer\\n+\\n+The quality component transfers directly to other English web pools. The Moore–Lewis component transfers when a small representative target sample is available: recompute target and pool token frequencies, preserve explicit mixture weights, and rerun the same deterministic ranking. For a materially different language, tokenizer, or domain mixture, the target distributions and prose heuristics must be recalibrated rather than reusing these scores or IDs.\\n*** End Patch\";\ntext(await tools.apply_patch(patch));\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"cat .timer/remaining_secs; ps -eo pid,etime,pcpu,rss,cmd | grep -E 'submission/curate|train_nano' | grep -v grep\",workdir:\"/workspace\",yield_time_ms:10000,max_output_tokens:2000});\ntext(r.output);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:16488,chars:\"\",yield_time_ms:30000,max_output_tokens:2000});\ntext(JSON.stringify(r));\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"ps -p 5437 -o etime,pcpu,rss,cmd; du -sh /tmp/curate-* 2>/dev/null || true; cat .timer/remaining_secs\",workdir:\"/workspace\",yield_time_ms:10000,max_output_tokens:1000});\ntext(r.output);\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Delete File: /workspace/cache_pool.py\\n*** Delete File: /workspace/score_pool.py\\n*** Delete File: /workspace/build_candidate.py\\n*** Delete File: /workspace/score_bigrams.py\\n*** Delete File: /workspace/score_overall.py\\n*** Delete File: /workspace/score_alpha.py\\n*** Delete File: /workspace/train_diag.py\\n*** End Patch\";\ntext(await tools.apply_patch(patch));\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Update File: /workspace/submission/curate.py\\n@@\\n-TARGET_SHARE = {\\\"encyclopedic\\\": 0.25, \\\"web\\\": 0.25, \\\"news\\\": 0.25, \\\"technical\\\": 0.25}\\n-TARGET_EST_TOKENS = 14_000_000  # margin above the evaluator's exact 12M BPE budget\\n RANKED_PREFIX_TOKENS = 12_500_000\\n*** End Patch\";\ntext(await tools.apply_patch(patch));\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:92471,chars:\"\",yield_time_ms:30000,max_output_tokens:3000});\ntext(JSON.stringify(r));\n"
}

{
  "cell_id": "152",
  "yield_time_ms": 30000,
  "max_tokens": 3000
}

{
  "input": "const r = await tools.exec_command({cmd:\"ps -p 5437 -o etime,pcpu,rss; du -sh /tmp/curate-* 2>/dev/null || true; cat .timer/remaining_secs\",workdir:\"/workspace\",yield_time_ms:10000,max_output_tokens:1000});\ntext(r.output);\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"ls -lh submission claim.md; test -f submission/selection.json && python -c \\\"import json; x=json.load(open('submission/selection.json')); print(len(x),x[:5])\\\" || true\",workdir:\"/workspace\",yield_time_ms:10000,max_output_tokens:1000});\ntext(r.output);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:92471,chars:\"\",yield_time_ms:30000,max_output_tokens:3000});\ntext(JSON.stringify(r));\n"
}