gpt-5.6-sol

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

{
  "input": "const r = await tools.write_stdin({session_id:58409,chars:\"\",yield_time_ms:30000,max_output_tokens:3000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const patch = \"*** Begin Patch\\n*** Add File: submission/curate.py\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Curate raw web text by target similarity, structural quality, and diversity.\\n+\\n+The disclosed 1M-token dev target consists of four consecutive equal-size\\n+registers.  For each register, this script learns smoothed word and word-bigram\\n+log-likelihood ratios against the whole raw pool.  Documents are ranked by a\\n+combination of (a) similarity to clean target text, (b) a domain-vs-other-domain\\n+margin, and (c) transparent structural quality penalties.  The four rankings\\n+are merged with a token-proxy scheduler so the usable prefix is balanced.\\n+Whitespace-normalized exact duplicates are removed.\\n+\\n+No IDs, labels, source domains, or hand-authored allowlists are embedded.\\n+\\\"\\\"\\\"\\n+from __future__ import annotations\\n+\\n+import collections\\n+import hashlib\\n+import json\\n+import math\\n+import os\\n+import re\\n+from pathlib import Path\\n+\\n+import numpy as np\\n+from transformers import GPT2TokenizerFast\\n+\\n+ROOT = Path(__file__).resolve().parents[1]\\n+POOL = ROOT / \\\"data\\\" / \\\"pool.jsonl\\\"\\n+DEV = ROOT / \\\"data\\\" / \\\"multi_dev.npy\\\"\\n+OUT = ROOT / \\\"submission\\\" / \\\"selection.json\\\"\\n+WORD = re.compile(r\\\"[A-Za-z]+(?:'[A-Za-z]+)?|\\\\d+|[^\\\\w\\\\s]\\\", re.ASCII)\\n+BAD = re.compile(\\n+    r\\\"cookie|privacy policy|terms of use|all rights reserved|sign in|log in|\\\"\\n+    r\\\"register|skip to content|add to cart|shopping cart|subscribe|advertis|\\\"\\n+    r\\\"javascript|follow us|share this|click here|home page\\\",\\n+    re.I,\\n+)\\n+DOMAIN_WEIGHT = 0.80\\n+MIN_CHARS, MAX_CHARS = 900, 30_000\\n+N_OUTPUT = 50_000  # comfortably exceeds 12M GPT-2 tokens\\n+\\n+\\n+def terms(text: str, limit: int = 2_200):\\n+    toks = WORD.findall(text.lower())[:limit]\\n+    words = [x for x in toks if x[0].isalnum()]\\n+    bigrams = [words[i] + \\\"_\\\" + words[i + 1] for i in range(len(words) - 1)]\\n+    return words, bigrams\\n+\\n+\\n+def add_counters(items):\\n+    return sum(items, collections.Counter())\\n+\\n+\\n+def ratio_weights(pos, background, min_count: int, cap: float):\\n+    \\\"\\\"\\\"Conservative smoothed log frequency ratios; discard topical singletons.\\\"\\\"\\\"\\n+    ptotal, btotal = sum(pos.values()), sum(background.values())\\n+    pv, bv = len(pos), len(background)\\n+    ans = {}\\n+    for key, count in pos.items():\\n+        if count < min_count:\\n+            continue\\n+        value = math.log((count + 2) / (ptotal + 2 * pv))\\n+        value -= math.log((background.get(key, 0) + 5) / (btotal + 5 * bv))\\n+        ans[key] = max(-cap, min(cap, value))\\n+    return ans\\n+\\n+\\n+def main():\\n+    tokenizer = GPT2TokenizerFast.from_pretrained(\\\"gpt2\\\", local_files_only=True)\\n+    dev = np.load(DEV)\\n+\\n+    # The disclosed target is four equal consecutive registers. EOS boundaries\\n+    # provide document-like positives without needing external labels.\\n+    domain_counts = []\\n+    for start in range(0, 1_000_000, 250_000):\\n+        docs = tokenizer.decode(dev[start : start + 250_000]).split(\\\"<|endoftext|>\\\")\\n+        unigrams, bigrams = collections.Counter(), collections.Counter()\\n+        for doc in docs:\\n+            words, pairs = terms(doc, 1_000_000)\\n+            unigrams.update(words)\\n+            bigrams.update(pairs)\\n+        domain_counts.append((unigrams, bigrams))\\n+\\n+    # Pool background makes ratios reward target-like editing/domain style and\\n+    # suppress ubiquitous crawl boilerplate.\\n+    bg_u, bg_b = collections.Counter(), collections.Counter()\\n+    with POOL.open() as handle:\\n+        for line in handle:\\n+            text = json.loads(line)[\\\"text\\\"]\\n+            words, pairs = terms(text)\\n+            bg_u.update(words)\\n+            bg_b.update(pairs)\\n+\\n+    target_u = add_counters(x[0] for x in domain_counts)\\n+    target_b = add_counters(x[1] for x in domain_counts)\\n+    quality_u = ratio_weights(target_u, bg_u, 4, 2.5)\\n+    quality_b = ratio_weights(target_b, bg_b, 3, 2.5)\\n+\\n+    domain_weights = []\\n+    for j, (pos_u, pos_b) in enumerate(domain_counts):\\n+        other_u = add_counters(domain_counts[k][0] for k in range(4) if k != j)\\n+        other_b = add_counters(domain_counts[k][1] for k in range(4) if k != j)\\n+        domain_weights.append(\\n+            (ratio_weights(pos_u, other_u, 3, 2.5),\\n+             ratio_weights(pos_b, other_b, 2, 2.5))\\n+        )\\n+\\n+    rows = []\\n+    content_hash = {}\\n+    with POOL.open() as handle:\\n+        for line in handle:\\n+            record = json.loads(line)\\n+            doc_id, text = record[\\\"id\\\"], record[\\\"text\\\"]\\n+            chars = len(text)\\n+            words, pairs = terms(text)\\n+            nw, nb = max(1, len(words)), max(1, len(pairs))\\n+\\n+            unigram_fit = sum(quality_u.get(x, 0.0) for x in words) / nw\\n+            bigram_fit = sum(quality_b.get(x, 0.0) for x in pairs) / nb\\n+            alpha = sum(c.isalpha() for c in text) / max(1, chars)\\n+            punct = (text.count(\\\".\\\") + text.count(\\\"?\\\") + text.count(\\\"!\\\")) / nw\\n+            nonempty = [x.strip() for x in text.splitlines() if x.strip()]\\n+            repetition = 1.0 - len(set(nonempty)) / max(1, len(nonempty))\\n+            boilerplate = len(BAD.findall(text)) / max(1.0, nw / 100.0)\\n+            length_term = -abs(math.log(max(chars, 600) / 3_200)) * 0.10\\n+            structure = -2.0 * max(0.0, 0.55 - alpha)\\n+            structure -= max(0.0, punct - 0.12)\\n+            structure -= 0.8 * max(0.0, 0.018 - punct)\\n+            structure -= 0.5 * repetition + 0.16 * boilerplate\\n+            structure -= 0.18 * text.count(\\\"<|endoftext|>\\\") + 0.02 * text.count(\\\"|\\\")\\n+            quality = 0.70 * unigram_fit + 0.55 * bigram_fit + length_term + structure\\n+\\n+            domain_scores = []\\n+            for weights_u, weights_b in domain_weights:\\n+                score = sum(weights_u.get(x, 0.0) for x in words) / nw\\n+                score += 0.65 * sum(weights_b.get(x, 0.0) for x in pairs) / nb\\n+                domain_scores.append(score)\\n+            rows.append((doc_id, chars, quality, domain_scores))\\n+            normalized = \\\" \\\".join(text.lower().split()).encode(\\\"utf-8\\\")\\n+            content_hash[doc_id] = hashlib.blake2b(normalized, digest_size=8).digest()\\n+\\n+    eligible = [r for r in rows if MIN_CHARS <= r[1] <= MAX_CHARS]\\n+    ranked = []\\n+    for domain in range(4):\\n+        def score(row):\\n+            own = row[3][domain]\\n+            other = max(row[3][k] for k in range(4) if k != domain)\\n+            return row[2] + DOMAIN_WEIGHT * (own - other)\\n+        ranked.append(sorted(eligible, key=lambda row: (-score(row), row[0])))\\n+\\n+    # Different registers have different characters/token. These fixed proxies\\n+    # were measured generically from GPT-2 BPE behavior (not from document IDs).\\n+    token_per_char = (0.27, 0.27, 0.27, 0.34)\\n+    positions = [0, 0, 0, 0]\\n+    totals = [0.0, 0.0, 0.0, 0.0]\\n+    used_ids, used_hashes, selection = set(), set(), []\\n+    while len(selection) < N_OUTPUT:\\n+        domain = min(range(4), key=lambda j: (totals[j], j))\\n+        while True:\\n+            row = ranked[domain][positions[domain]]\\n+            positions[domain] += 1\\n+            doc_id = row[0]\\n+            digest = content_hash[doc_id]\\n+            if doc_id not in used_ids and digest not in used_hashes:\\n+                break\\n+        used_ids.add(doc_id)\\n+        used_hashes.add(digest)\\n+        selection.append(doc_id)\\n+        totals[domain] += row[1] * token_per_char[domain]\\n+\\n+    OUT.parent.mkdir(parents=True, exist_ok=True)\\n+    with OUT.open(\\\"w\\\") as handle:\\n+        json.dump(selection, handle)\\n+    print(f\\\"wrote {len(selection)} unique IDs to {OUT}\\\")\\n+    print(\\\"estimated domain tokens:\\\", [round(x) for x in totals])\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+    main()\\n*** End Patch\";\ntext(await tools.apply_patch(patch));\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Add File: claim.md\\n+# Hypothesis\\n+\\n+For a 12M-token training budget, a balanced prefix of clean documents whose word and phrase distributions resemble each disclosed target register will outperform either random web data or a single global “quality” ranking. Exact duplicate removal should further improve the useful information per token.\\n+\\n+# Mechanism\\n+\\n+The selector estimates smoothed word and bigram likelihood ratios from each of the four equal 250k-token dev registers against the raw pool. It combines target fit with transparent penalties for boilerplate, repeated lines, markup, implausible punctuation density, and extreme length. Four domain rankings are then merged in estimated-token balance, with normalized exact duplicates suppressed.\\n+\\n+An observable prediction independent of final perplexity is that the consumed prefix will have approximately one-quarter of its estimated tokens assigned to each register, fewer duplicate bytes and boilerplate phrases than a random prefix, and visibly distinct high-ranked strata: encyclopedic descriptions, edited general prose, attributed news, and code-centered technical material.\\n+\\n+# Falsification\\n+\\n+The hypothesis is falsified if blinded samples from the selected prefix are not rated cleaner and more register-matched than random samples, if the realized token shares are materially unbalanced, or if removing the target-likelihood/domain-margin terms does not degrade held-out next-token loss consistently across reruns. It would also be weakened if exact deduplication fails to increase unique normalized text per 12M tokens.\\n+\\n+# Transfer\\n+\\n+The method transfers to another corpus or target by replacing only the disclosed target sample and re-estimating likelihood ratios; it contains no source-domain allowlist or hand-picked IDs. The quality features and deduplication are language/crawl controls, while the balanced merge can accommodate any known target mixture by changing its register token weights.\\n*** End Patch\";\ntext(await tools.apply_patch(patch));\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"python submission/curate.py\",\"workdir\":\"/workspace\",\"yield_time_ms\":1000,\"max_output_tokens\":2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}

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

{
  "input": "const r = await tools.write_stdin({session_id:89296,chars:\"\",yield_time_ms:30000,max_output_tokens:2000}); text(r.output); if(r.session_id) text(`SESSION_ID=${r.session_id}`)\n"
}