OpenAI math manuscripts: LaTeX sources + OCR reasoning summaries (openai/math@adc7f12)

README.md

@@ -0,0 +1,131 @@
+---
+license: apache-2.0
+language:
+- en
+pretty_name: OpenAI Math Manuscripts
+size_categories:
+- n<1K
+task_categories:
+- text-generation
+tags:
+- mathematics
+- latex
+- research-mathematics
+- reasoning
+- chain-of-thought
+configs:
+- config_name: papers
+  default: true
+  data_files:
+  - split: train
+    path: data/papers.parquet
+- config_name: reasoning_summaries
+  data_files:
+  - split: train
+    path: data/reasoning_summaries.parquet
+- config_name: overview
+  data_files:
+  - split: train
+    path: data/overview.parquet
+---
+
+# OpenAI Math Manuscripts
+
+This dataset is a machine-readable copy of [`openai/math`](https://github.com/openai/math) at commit
+[`adc7f12`](https://github.com/openai/math/tree/adc7f1241b42e322a6451854ab7e4b4c146bf78a). That
+repository holds research manuscripts produced by an internal OpenAI model.
+
+| Config | Rows | Content |
+|---|---:|---|
+| `papers` (default) | 722 | Full LaTeX source of every manuscript in `preprints/` (372 result families, 17 subjects, 34,815 PDF pages, ~36.4M tokens with o200k_base) |
+| `reasoning_summaries` | 10 | Abridged summaries of the model's reasoning from `reasoning_traces/`, transcribed to Markdown + LaTeX (~149k tokens) |
+| `overview` | 1 | LaTeX source of the catalogue `overview.pdf` |
+
+```python
+from datasets import load_dataset
+papers = load_dataset("ituperceptron/openai-math", "papers", split="train")
+summaries = load_dataset("ituperceptron/openai-math", "reasoning_summaries", split="train")
+```
+
+## How the text was produced
+
+**Papers: from the source, not the PDFs.** Every manuscript is published with its LaTeX source
+under `build/`. We take the root file (the one containing `\begin{document}`) and inline every
+`\input` and `\lstinputlisting` recursively. We remove `%` comments, but leave verbatim and listing
+environments untouched. One manuscript bundles two standalone documents with `\includepdf`, so its
+`latex` field holds both documents one after the other. The text is never OCR'd, so formulas are
+exactly as the authors wrote them. Bibliographies are either inline `thebibliography` blocks in
+`latex` or the referenced `.bib` files in `bib`. Figures are left as TikZ code or
+`\includegraphics` references.
+
+**Reasoning summaries: OCR with a vision model.** OpenAI released 9 of the 10 summaries only as
+PDFs. We sent each page (rendered at 150 dpi) together with the PDF text layer to `gpt-6-sol`
+(OpenAI). The text layer supplies exact spelling. The image supplies structure and math, which plain
+text extraction breaks: flattened sub/superscripts, Unicode italic letters, lost spaces, split
+ligatures. The model was told to transcribe the page verbatim:
+
+- prose as Markdown, with math as `$…$` / `$$…$$`;
+- original-prompt excerpts and `VERBATIM EXCERPT` passages as ```` ```text ```` blocks, copied as
+  written;
+- running headers and page numbers dropped.
+
+Page outputs were then joined, continuing paragraphs and code blocks across page breaks. A
+word-level comparison with the text layer shows no dropped content. The only differences are
+hyphenation and ligature fragments that the text layer had split. The Mézard–Parisi summary also
+has an official LaTeX source, which is included in its `latex` field.
+
+## Fields
+
+### `papers`
+
+| Field | Description |
+|---|---|
+| `id` | Manuscript directory name in `preprints/` |
+| `family` | Result family number (`001`–`372`); a family groups a main result with companions and alternative proofs |
+| `subject` | Subject heading from `overview.tex` (e.g. Number theory, Combinatorics) |
+| `family_title`, `family_summary` | Family title and description from `CONTENTS.md` |
+| `title`, `abstract` | Manuscript title and abstract from `CONTENTS.md` (Markdown with `$…$` math) |
+| `note` | Annotation next to the link in `CONTENTS.md` (e.g. `secondary writeup`), otherwise null |
+| `date` | Release date from the directory name (ISO) |
+| `latex` | Flattened LaTeX source of the whole document, including the preamble and macros |
+| `bib` | Contents of the `.bib` files referenced by `\bibliography`, otherwise null |
+| `num_pages` | Page count of the published PDF |
+| `has_lean` | Whether the family has a Lean formalization in the source repository |
+| `pdf_url`, `source_dir_url` | Published PDF and source directory at the pinned commit |
+
+### `reasoning_summaries`
+
+| Field | Description |
+|---|---|
+| `family`, `subject`, `title` | Result family, subject, and title from the source README |
+| `slug` | Source file name without extension |
+| `markdown` | Transcribed text (Markdown + LaTeX) |
+| `latex` | Official LaTeX source when published (only `mezard-parisi-formula`), otherwise null |
+| `num_pages`, `ocr_model`, `pdf_url` | PDF page count, transcription model, and source PDF |
+
+## Limitations
+
+- OpenAI notes that some results have not been formalized and could contain errors. The text here
+  is reproduced as published; it has not been checked.
+- The `latex` documents are flattened but not normalized. Package files, figures, and the
+  pdfTeX-only `\input glyphtounicode` lines are still referenced but not included, so not every
+  document compiles as-is.
+- Model transcription of the reasoning summaries can still contain small errors in math. When an
+  exact formula matters, check it against `pdf_url`.
+- The `reasoning_summaries` are OpenAI's abridged third-person summaries ("the assistant
+  considered…"), not raw chains of thought.
+
+## Reproduction
+
+The build scripts are in this repository under `scripts/`. Steps:
+
+1. `build_papers.py` clones the pinned commit without the Lean library and writes the `papers` and
+   `overview` configs.
+2. `ocr_reasoning.py` transcribes the summary PDFs page by page and caches each page.
+3. `build_reasoning.py` joins the cached pages into `reasoning_summaries`.
+
+## License
+
+Apache License 2.0, the same as the source repository. Content © OpenAI. The reasoning-summary
+transcriptions were produced with an OpenAI model (`gpt-6-sol`). Packaged by
+[ITU Perceptron](https://huggingface.co/ituperceptron).

data/overview.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6fe230726de213b9ff66e5724ee2f3c4215d10e0b0cc96697d5c1f9aa3a0e8c
+size 129887

data/papers.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c7ac1e33937373ad72e8cb7ae4c95393a3e3a8063c6b1e2d059265e605049ca
+size 67185639

data/reasoning_summaries.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b15ad787c5a47260c8aeab59acc89690e91139646a0cce9d14e6d305c4c58a30
+size 383399

scripts/build_papers.py

@@ -0,0 +1,274 @@
+"""openai/math preprint'lerinin LaTeX kaynaklarını tek dosyaya açıp parquet üretir.
+
+PDF'ler OCR'lanmaz: her makalenin `build/` altındaki kaynağı kullanılır. Kök .tex
+dosyasındaki `\\input` ve `\\lstinputlisting` çağrıları içerikle değiştirilir, yorumlar
+atılır; `\\includepdf` ile birleştirilen alt belgeler sırayla eklenir. Aile, konu ve
+özet bilgileri `CONTENTS.md` ile `overview.tex` dosyalarından alınır.
+
+    python3 build_papers.py   # -> data/papers.parquet, data/overview.parquet
+"""
+import re
+import subprocess
+from pathlib import Path
+
+import fitz  # PyMuPDF; yalnız sayfa sayısı için
+import pandas as pd
+
+REPO = "openai/math"
+COMMIT = "adc7f1241b42e322a6451854ab7e4b4c146bf78a"
+BLOB = f"https://github.com/{REPO}/blob/{COMMIT}/"
+SPARSE = ["/preprints/", "/reasoning_traces/", "/overview.*", "/CONTENTS.md", "/README.md", "/LICENSE"]
+
+HERE = Path(__file__).parent
+SRC = HERE / "raw" / "math"
+OUT = HERE / "data"
+
+# `(?<!\\)`: `\\input 1` (satır sonu + metin) komut değildir.
+INPUT_RE = re.compile(r"(?<!\\)\\input(?:\s*\{([^}]*)\}|\s+([^\s{}\\]+))")
+LST_RE = re.compile(r"(?<!\\)\\lstinputlisting\s*(\[[^\]]*\])?\s*\{([^}]*)\}")
+INCLUDEPDF_RE = re.compile(r"(?<!\\)\\includepdf\s*(?:\[[^\]]*(?:\{[^}]*\}[^\]]*)*\])?\s*\{([^}]*)\}")
+BIB_RE = re.compile(r"(?<!\\)\\bibliography\s*\{([^}]*)\}")
+# pdfTeX'in kendi dosyaları; kaynakta yoktur, olduğu gibi bırakılır.
+TEX_SYSTEM_INPUTS = {"glyphtounicode", "glyphtounicode-cmex", "glyphtounicode-cmr"}
+BEGIN_DOC_RE = re.compile(r"^[^%\n]*\\begin\{document\}", re.M)
+DATE_RE = re.compile(r"-((?:January|February|March|April|May|June|July|August|September|October|November|December)-\d{1,2}-\d{4}|\d{4}-\d{2}-\d{2})$")
+
+
+def fetch_source():
+    """Pinned commit'i Lean dosyaları olmadan klonlar (önbellek varsa atlar)."""
+    if (SRC / "CONTENTS.md").exists():
+        head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=SRC, capture_output=True, text=True).stdout.strip()
+        if head != COMMIT:
+            raise SystemExit(f"{SRC} commit {head}, beklenen {COMMIT}")
+        return
+    SRC.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(["git", "clone", "-q", "--filter=blob:none", "--no-checkout",
+                    f"https://github.com/{REPO}.git", str(SRC)], check=True)
+    subprocess.run(["git", "sparse-checkout", "set", "--no-cone", *SPARSE], cwd=SRC, check=True)
+    subprocess.run(["git", "checkout", "-q", COMMIT], cwd=SRC, check=True)
+
+
+VERBATIM_BEGIN = re.compile(r"\\begin\{(verbatim\*?|Verbatim|lstlisting|minted)\}")
+
+
+def strip_comments(tex: str) -> str:
+    """`%` yorumlarını atar; tamamı yorum olan satırlar silinir, verbatim ortamlarına dokunulmaz."""
+    out, verb = [], None
+    for line in tex.split("\n"):
+        if verb:
+            out.append(line)
+            if f"\\end{{{verb}}}" in line:
+                verb = None
+            continue
+        i = 0
+        while True:
+            i = line.find("%", i)
+            if i < 0:
+                kept = line
+                break
+            backslashes = len(line[:i]) - len(line[:i].rstrip("\\"))
+            if backslashes % 2 == 0:
+                kept = line[:i].rstrip() if line[:i].strip() else None
+                break
+            i += 1
+        if kept is None:
+            continue
+        out.append(kept)
+        m = VERBATIM_BEGIN.search(kept)
+        if m and f"\\end{{{m.group(1)}}}" not in kept[m.end():]:
+            verb = m.group(1)
+    return "\n".join(out)
+
+
+def resolve(name: str, cur: Path, root: Path, exts=(".tex", "")):
+    for base in (root, cur):
+        for ext in exts:
+            p = base / (name + ext)
+            if p.is_file():
+                return p
+    return None
+
+
+def flatten(path: Path, root: Path, pkg: Path, missing: list, seen=()) -> str:
+    """`root`: \\input yollarının göreli olduğu dizin; `pkg`: makalenin preprints/ dizini."""
+    if path in seen:
+        raise RuntimeError(f"döngüsel input: {path}")
+    tex = strip_comments(path.read_text(encoding="utf-8", errors="replace"))
+    cur = path.parent
+
+    def sub_input(m):
+        name = (m.group(1) or m.group(2)).strip()
+        if re.sub(r"\.tex$", "", name) in TEX_SYSTEM_INPUTS:
+            return m.group(0)
+        p = resolve(name, cur, root)
+        if p is None:
+            missing.append(name)
+            return m.group(0)
+        return flatten(p, root, pkg, missing, seen + (path,)).strip("\n")
+
+    def sub_lst(m):
+        name = m.group(2).strip()
+        p = resolve(name, cur, root, exts=("",))
+        if p is None:
+            # Yayında dizin adı değişmiş olabilir (certificate/ -> verification/): tek eşleşen ada düş.
+            hits = list(pkg.rglob(Path(name).name))
+            p = hits[0] if len(hits) == 1 else None
+        if p is None:
+            missing.append(name)
+            return m.group(0)
+        code = p.read_text(encoding="utf-8", errors="replace").rstrip("\n")
+        return f"\\begin{{lstlisting}}{m.group(1) or ''}\n{code}\n\\end{{lstlisting}}"
+
+    tex = LST_RE.sub(sub_lst, tex)
+    return INPUT_RE.sub(sub_input, tex)
+
+
+def flatten_paper(root: Path, pkg: Path, missing: list) -> str:
+    """Kök yalnız `\\includepdf` ile ayrı belgeleri birleştiriyorsa, o belgeleri sırayla açar.
+
+    Sarmalayıcı kök derlenmiş PDF'leri iliştirir; metin alt belgelerin kaynağındadır.
+    """
+    parts = INCLUDEPDF_RE.findall(strip_comments(root.read_text(encoding="utf-8", errors="replace")))
+    if not parts:
+        return collapse(flatten(root, root.parent, pkg, missing))
+    docs = []
+    for name in parts:
+        p = resolve(re.sub(r"\.pdf$", "", name.strip()), root.parent, root.parent, exts=(".tex",))
+        if p is None:
+            missing.append(name)
+            continue
+        docs.append(collapse(flatten(p, root.parent, pkg, missing)))
+    return "\n".join(docs)
+
+
+def collapse(tex: str) -> str:
+    tex = "\n".join(line.rstrip() for line in tex.split("\n"))
+    return re.sub(r"\n{3,}", "\n\n", tex).strip() + "\n"
+
+
+def find_root(d: Path, pdf: Path) -> Path:
+    """`\\begin{document}` içeren .tex; birden fazlaysa PDF adıyla ya da main ile eşleşen en sığ dosya.
+
+    `\\documentclass` aranmaz: bazı makalelerde o satır `\\input` edilen preamble dosyasında.
+    """
+    roots = [p for p in d.rglob("*.tex") if BEGIN_DOC_RE.search(p.read_text(encoding="utf-8", errors="replace"))]
+    if len(roots) == 1:
+        return roots[0]
+    for key in (pdf.stem, "main"):
+        hit = sorted((p for p in roots if p.stem == key), key=lambda p: len(p.parts))
+        if len(hit) == 1 or len(hit) > 1 and len(hit[0].parts) < len(hit[1].parts):
+            return hit[0]
+    raise RuntimeError(f"kök .tex belirsiz: {d.name}: {roots}")
+
+
+def bib_text(tex: str, root: Path) -> str:
+    parts = []
+    for m in BIB_RE.finditer(tex):
+        for name in m.group(1).split(","):
+            p = resolve(name.strip(), root, root, exts=(".bib", ""))
+            if p is not None:
+                parts.append(p.read_text(encoding="utf-8", errors="replace").strip())
+    return "\n\n".join(parts) or None
+
+
+def md_inline(s: str) -> str:
+    """CONTENTS.md'deki HTML/GitHub-math işaretlerini sade Markdown+LaTeX'e çevirir."""
+    s = re.sub(r"\$`(.*?)`\$", r"$\1$", s)
+    s = re.sub(r"</?i>", "*", s)
+    s = re.sub(r"</?b>", "**", s)
+    s = re.sub(r"</?sub>|</?sup>", "", s)
+    for a, b in (("&gt;", ">"), ("&lt;", "<"), ("&amp;", "&"), ("&emsp;", ""), ("&nbsp;", " ")):
+        s = s.replace(a, b)
+    s = s.replace("\\gt", ">").replace("\\lt", "<")
+    return s.strip()
+
+
+def parse_contents(text: str) -> dict:
+    """pdf yolu -> {family, family_title, family_summary, title, abstract, lean_doc}."""
+    cells = re.findall(r"<td>\n\n(.*?)\n\n</td>", text, re.S)
+    fam = None
+    out = {}
+    for cell in cells:
+        m = re.match(r"\*\*(\d{3})\. (.*?)\*\* (.*)", cell, re.S)
+        if m:
+            summary = m.group(3)
+            lean = re.search(r"\(\[Lean\]\((lean/docs/\d+\.md)\)\)", summary)
+            summary = re.sub(r"\s*\(\[Lean\]\([^)]*\)\)", "", summary)
+            fam = {"family": m.group(1), "family_title": md_inline(m.group(2)).rstrip("."),
+                   "family_summary": md_inline(summary), "lean_doc": lean.group(1) if lean else None}
+            continue
+        m = re.match(r"&emsp;\[(.*)\]\((preprints/[^\n]+?\.pdf)\)([^\n]*)\n\n(.*)", cell, re.S)
+        if not m:
+            raise RuntimeError(f"tanınmayan hücre: {cell[:120]}")
+        note = m.group(3).strip(" —") or None
+        out[m.group(2)] = dict(fam, title=md_inline(m.group(1)), note=note, abstract=md_inline(m.group(4)))
+    return out
+
+
+def parse_subjects(tex: str) -> dict:
+    subj, out = None, {}
+    for m in re.finditer(r"\\cataloguesection\{([^}]*)\}|\\resultentry\{(\d{3})\}", tex):
+        if m.group(1):
+            subj = m.group(1)
+        else:
+            out[m.group(2)] = subj
+    return out
+
+
+def parse_date(name: str):
+    m = DATE_RE.search(name)
+    if not m:
+        return None
+    fmt = "%Y-%m-%d" if m.group(1)[0].isdigit() else "%B-%d-%Y"
+    return pd.to_datetime(m.group(1), format=fmt).date().isoformat()
+
+
+def main():
+    fetch_source()
+    contents = parse_contents((SRC / "CONTENTS.md").read_text(encoding="utf-8"))
+    subjects = parse_subjects((SRC / "overview.tex").read_text(encoding="utf-8"))
+    rows, problems = [], []
+    for pdf_rel, meta in contents.items():
+        pdf = SRC / pdf_rel
+        d = pdf.parent
+        root = find_root(d, pdf)
+        missing = []
+        latex = flatten_paper(root, d, missing)
+        if missing:
+            problems.append((d.name, missing))
+        for needle in ("\\documentclass", "\\begin{document}", "\\end{document}"):
+            if needle not in latex:
+                problems.append((d.name, [f"{needle} yok"]))
+        with fitz.open(pdf) as doc:
+            num_pages = doc.page_count
+        rows.append({
+            "id": d.name,
+            "family": meta["family"],
+            "subject": subjects[meta["family"]],
+            "family_title": meta["family_title"],
+            "family_summary": meta["family_summary"],
+            "title": meta["title"],
+            "note": meta["note"],
+            "abstract": meta["abstract"],
+            "date": parse_date(d.name),
+            "latex": latex,
+            "bib": bib_text(latex, root.parent),
+            "num_pages": num_pages,
+            "has_lean": meta["lean_doc"] is not None,
+            "pdf_url": BLOB + pdf_rel,
+            "source_dir_url": BLOB.replace("/blob/", "/tree/") + str(root.parent.relative_to(SRC)),
+        })
+    OUT.mkdir(exist_ok=True)
+    df = pd.DataFrame(rows).sort_values(["family", "id"]).reset_index(drop=True)
+    df.to_parquet(OUT / "papers.parquet", index=False)
+
+    overview = collapse(strip_comments((SRC / "overview.tex").read_text(encoding="utf-8")))
+    pd.DataFrame([{"latex": overview, "pdf_url": BLOB + "overview.pdf"}]).to_parquet(OUT / "overview.parquet", index=False)
+
+    print(f"{len(df)} makale, {df.family.nunique()} aile, {df.subject.nunique()} konu")
+    for name, miss in problems:
+        print("ÇÖZÜLEMEYEN:", name, miss)
+
+
+if __name__ == "__main__":
+    main()

scripts/build_reasoning.py

@@ -0,0 +1,73 @@
+"""`ocr_reasoning.py` sayfa çıktılarını belge başına birleştirip parquet üretir.
+
+    python3 build_reasoning.py   # -> data/reasoning_summaries.parquet
+"""
+import json
+import re
+from pathlib import Path
+
+import fitz
+import pandas as pd
+
+from build_papers import BLOB, SRC, OUT, parse_subjects, strip_comments, collapse
+
+TRACES = SRC / "reasoning_traces"
+OCR = Path(__file__).parent / "raw" / "ocr"
+SENTENCE_END = re.compile(r"[.!?:;)\]$`*]\s*$")
+BLOCK_START = re.compile(r"^(#|>|```|[-*+] |\d+\. |\||\$\$)")
+
+
+def readme_table() -> dict:
+    """README 'Reasoning summaries' tablosu: slug -> (family, title)."""
+    text = (SRC / "README.md").read_text(encoding="utf-8")
+    rows = re.findall(r"^\| (\d{3}) \| \[(.+?)\]\(reasoning_traces/([^)]+)\.pdf\) \|$", text, re.M)
+    return {slug: (fam, title) for fam, title, slug in rows}
+
+
+def join_pages(pages: list) -> str:
+    out = pages[0]
+    for page in pages[1:]:
+        # Sayfa sonunda kapanıp sonraki sayfada yeniden açılan aynı kod bloğunu birleştir.
+        if out.endswith("```") and page.startswith("```text"):
+            out = out[:-3].rstrip("\n") + "\n" + page[len("```text"):].lstrip("\n")
+        # Sayfa cümle ortasında bitiyorsa paragrafı sürdür (satır sonu tirelerinde boşluksuz).
+        elif not SENTENCE_END.search(out) and not BLOCK_START.match(page):
+            out = out.rstrip() + ("" if out.rstrip().endswith(("–", "-")) else " ") + page
+        else:
+            out = out.rstrip() + "\n\n" + page
+    return re.sub(r"\n{3,}", "\n\n", out).strip() + "\n"
+
+
+def main():
+    table = readme_table()
+    subjects = parse_subjects((SRC / "overview.tex").read_text(encoding="utf-8"))
+    rows = []
+    for pdf in sorted(TRACES.glob("*.pdf")):
+        with fitz.open(pdf) as doc:
+            n = doc.page_count
+        files = [OCR / pdf.stem / f"{i:03d}.json" for i in range(1, n + 1)]
+        missing = [f.name for f in files if not f.exists()]
+        if missing:
+            raise SystemExit(f"{pdf.stem}: OCR eksik sayfalar {missing}")
+        pages = [json.loads(f.read_text()) for f in files]
+        tex = pdf.with_suffix(".tex")
+        fam, title = table[pdf.stem]
+        rows.append({
+            "family": fam,
+            "subject": subjects[fam],
+            "title": title,
+            "slug": pdf.stem,
+            "markdown": join_pages([p["markdown"] for p in pages]),
+            "latex": collapse(strip_comments(tex.read_text(encoding="utf-8"))) if tex.exists() else None,
+            "num_pages": n,
+            "ocr_model": ",".join(sorted({p["model"] for p in pages})),
+            "pdf_url": BLOB + f"reasoning_traces/{pdf.name}",
+        })
+    df = pd.DataFrame(rows).sort_values("family").reset_index(drop=True)
+    OUT.mkdir(exist_ok=True)
+    df.to_parquet(OUT / "reasoning_summaries.parquet", index=False)
+    print(df[["family", "slug", "num_pages"]].assign(chars=df.markdown.str.len()).to_string())
+
+
+if __name__ == "__main__":
+    main()

scripts/ocr_reasoning.py

@@ -0,0 +1,115 @@
+"""openai/math reasoning_traces PDF'lerini sayfa sayfa OpenAI vision ile Markdown+LaTeX'e çevirir.
+
+Her sayfa için görüntü ve PyMuPDF metin katmanı birlikte gönderilir: kelimeler metin
+katmanından doğru okunur, formül yapısı görüntüden kurulur. Sonuç sayfa başına
+`raw/ocr/<slug>/<sayfa>.json` olarak saklanır; yeniden çalıştırınca biten sayfalar atlanır.
+Kota 1M grubundan düşer; `--budget` aşılmadan durur (önceki çalıştırmalar dahil).
+
+    python3 ocr_reasoning.py --pages irrationality-exponent-of-pi:5   # pilot
+    python3 ocr_reasoning.py                                          # hepsi
+"""
+import argparse
+import base64
+import json
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import fitz
+from dotenv import load_dotenv
+from openai import OpenAI
+
+HERE = Path(__file__).parent
+TRACES = HERE / "raw" / "math" / "reasoning_traces"
+OCR = HERE / "raw" / "ocr"
+MODEL = "gpt-6-sol"
+EFFORT = "none"
+DPI = 150
+
+PROMPT = """You are transcribing one page of a mathematics document (an abridged summary of a model's chain of thought) into Markdown with LaTeX math.
+
+You get the page image and the PDF's text layer. The text layer has the correct words but broken math: italic Unicode letters, lost spaces, flattened sub/superscripts, broken line wraps. Use the image as the authority for structure and math, and the text layer to spell words exactly.
+
+Rules:
+- Transcribe everything on the page in reading order, verbatim. Do not summarize, correct, complete, or add anything.
+- Math: inline as $...$, display as $$...$$ on their own lines. Use standard LaTeX (\\pi, \\mathbb{Z}, x^{2}, a_{k}, \\frac{}{}, \\le). No Unicode math letters.
+- Headings as Markdown headings (#, ##, ###) matching the visual hierarchy. Keep bold/italic. Lists as Markdown lists. Tables as Markdown tables.
+- Monospace quoted blocks (original prompt excerpts and "VERBATIM EXCERPT" passages): put the label shown above the block, if any, on its own line in bold (`**VERBATIM EXCERPT**`), then the block text in a ```text fenced block. Copy it exactly as written; do not convert its ASCII math to LaTeX. Join lines that wrap only because they reached the right margin; keep real line breaks (list items, indented lines, blank lines).
+- Join lines that wrap within a paragraph; remove hyphenation introduced by line breaks; separate paragraphs with one blank line.
+- Omit running headers, footers and page numbers.
+- If the page begins or ends mid-sentence, begin or end mid-sentence as well.
+- Keep URLs, citation markers like [17], and reference list entries exactly.
+
+Output only the page's Markdown, with no preamble and no surrounding code fence."""
+
+
+def page_inputs(pdf: Path, index: int):
+    with fitz.open(pdf) as doc:
+        page = doc[index]
+        png = page.get_pixmap(dpi=DPI).tobytes("png")
+        text = page.get_text("text")
+    return base64.b64encode(png).decode(), text
+
+
+def ocr_page(client: OpenAI, pdf: Path, index: int, model: str, effort: str) -> dict:
+    img, text = page_inputs(pdf, index)
+    resp = client.responses.create(
+        model=model,
+        reasoning={"effort": effort},
+        input=[{"role": "user", "content": [
+            {"type": "input_text", "text": PROMPT},
+            {"type": "input_text", "text": f"Text layer of page {index + 1}:\n<<<\n{text}\n>>>"},
+            {"type": "input_image", "image_url": f"data:image/png;base64,{img}", "detail": "high"},
+        ]}],
+    )
+    if resp.status != "completed":
+        raise RuntimeError(f"{pdf.stem} s.{index + 1}: {resp.status} {resp.incomplete_details}")
+    u = resp.usage
+    return {"slug": pdf.stem, "page": index + 1, "model": model, "markdown": resp.output_text.strip(),
+            "input_tokens": u.input_tokens, "output_tokens": u.output_tokens,
+            "reasoning_tokens": u.output_tokens_details.reasoning_tokens}
+
+
+def spent() -> int:
+    return sum(r["input_tokens"] + r["output_tokens"]
+               for r in (json.loads(p.read_text()) for p in OCR.glob("*/*.json")))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pages", nargs="*", help="slug:sayfa (1 tabanlı); verilmezse tüm PDF'ler")
+    ap.add_argument("--model", default=MODEL)
+    ap.add_argument("--effort", default=EFFORT, help="modelin desteklediği en düşük reasoning effort")
+    ap.add_argument("--budget", type=int, default=900_000, help="tüm çalıştırmalar için toplam token sınırı")
+    ap.add_argument("--workers", type=int, default=8)
+    args = ap.parse_args()
+    load_dotenv(HERE.parents[1] / ".env")
+    client = OpenAI()
+
+    if args.pages:
+        jobs = [(TRACES / f"{s.split(':')[0]}.pdf", int(s.split(':')[1]) - 1) for s in args.pages]
+    else:
+        jobs = []
+        for pdf in sorted(TRACES.glob("*.pdf")):
+            with fitz.open(pdf) as doc:
+                jobs += [(pdf, i) for i in range(doc.page_count)]
+    jobs = [(pdf, i) for pdf, i in jobs if not (OCR / pdf.stem / f"{i + 1:03d}.json").exists()]
+
+    used = spent()
+    print(f"{len(jobs)} sayfa kaldı, şimdiye kadar {used:,} token", flush=True)
+    with ThreadPoolExecutor(args.workers) as pool:
+        pending = list(jobs)
+        while pending:
+            if used >= args.budget:
+                sys.exit(f"bütçe doldu: {used:,} >= {args.budget:,}; {len(pending)} sayfa kaldı")
+            batch, pending = pending[:args.workers], pending[args.workers:]
+            for r in pool.map(lambda j: ocr_page(client, j[0], j[1], args.model, args.effort), batch):
+                out = OCR / r["slug"] / f"{r['page']:03d}.json"
+                out.parent.mkdir(parents=True, exist_ok=True)
+                out.write_text(json.dumps(r, ensure_ascii=False, indent=1))
+                used += r["input_tokens"] + r["output_tokens"]
+                print(f"{r['slug']} s.{r['page']}: {r['input_tokens']}+{r['output_tokens']} (toplam {used:,})", flush=True)
+
+
+if __name__ == "__main__":
+    main()