Datasets:
Download components/openai-math/tools/build_openai_math.py from MMLA-ORG/Cayley-Math: direct link, hf CLI and curl.
- Browser
- Download file 41.5 kB
-
https://huggingface.co/datasets/MMLA-ORG/Cayley-Math/resolve/main/components/openai-math/tools/build_openai_math.py
- Command line
-
hf download hf://datasets/MMLA-ORG/Cayley-Math/components/openai-math/tools/build_openai_math.py
-
curl -L -o build_openai_math.py https://huggingface.co/datasets/MMLA-ORG/Cayley-Math/resolve/main/components/openai-math/tools/build_openai_math.py
41.5 kB
| #!/usr/bin/env python3 | |
| """Build a source-faithful, provenance-rich Cayley-Math contribution staging tree. | |
| No model calls, TeX compilation, source code execution, or network access. | |
| """ | |
| import argparse | |
| import collections | |
| import hashlib | |
| import html | |
| import json | |
| import re | |
| import subprocess | |
| from pathlib import Path | |
| from urllib.parse import quote, unquote | |
| LICENSE = 'Apache-2.0' | |
| REPO_URL = 'https://github.com/openai/math' | |
| def dump(path, obj): | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| path.write_text(json.dumps(obj, ensure_ascii=False, indent=2) + '\n') | |
| def jsonl(path, rows): | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| with path.open('w') as f: | |
| for row in rows: | |
| f.write(json.dumps(row, ensure_ascii=False, separators=(',', ':')) + '\n') | |
| def digest(path): | |
| return hashlib.sha256(path.read_bytes()).hexdigest() | |
| def uncomment(text): | |
| # TeX comments begin at an unescaped percent; retain line count for provenance. | |
| out, verbatim = [], None | |
| for line in text.splitlines(keepends=True): | |
| if verbatim: | |
| out.append(line) | |
| if '\\end{' + verbatim + '}' in line: | |
| verbatim = None | |
| continue | |
| verbatim_start = re.search(r'\\begin\{(lstlisting|verbatim|Verbatim|minted)\}', line) | |
| if verbatim_start: | |
| out.append(line) | |
| if '\\end{' + verbatim_start.group(1) + '}' not in line[verbatim_start.end():]: | |
| verbatim = verbatim_start.group(1) | |
| continue | |
| literal_ranges = [] | |
| for inline in re.finditer(r'\\(?:verb\*?|lstinline)(?![A-Za-z@])(?:\[[^\]\n]*\])?', line): | |
| start = inline.end() | |
| if start >= len(line) or line[start].isspace(): | |
| continue | |
| delimiter = line[start] | |
| close = '}' if delimiter == '{' and 'lstinline' in inline.group() else delimiter | |
| end = line.find(close, start + 1) | |
| literal_ranges.append((start, len(line) if end < 0 else end + 1)) | |
| for i, ch in enumerate(line): | |
| if ch == '%': | |
| if any(a <= i < b for a, b in literal_ranges): | |
| continue | |
| n = 0 | |
| j = i - 1 | |
| while j >= 0 and line[j] == '\\': | |
| n += 1 | |
| j -= 1 | |
| if not n % 2: | |
| line = line[:i] + ('\n' if line.endswith('\n') else '') | |
| break | |
| out.append(line) | |
| return ''.join(out) | |
| def group_at(s, p): | |
| while p < len(s) and s[p].isspace(): | |
| p += 1 | |
| if p >= len(s) or s[p] != '{': | |
| raise ValueError('Expected brace group at %d' % p) | |
| depth, start = 1, p + 1 | |
| p += 1 | |
| while p < len(s): | |
| if s[p] == '\\': | |
| p += 2 | |
| continue | |
| if s[p] == '{': | |
| depth += 1 | |
| elif s[p] == '}': | |
| depth -= 1 | |
| if depth == 0: | |
| return s[start:p], p + 1 | |
| p += 1 | |
| raise ValueError('Unclosed brace group') | |
| def args_at(s, p, n): | |
| values = [] | |
| for _ in range(n): | |
| value, p = group_at(s, p) | |
| values.append(value) | |
| return values, p | |
| def clean_html(s): | |
| s = re.sub(r'<[^>]+>', '', s) | |
| s = html.unescape(s).replace('$`', '$').replace('`$', '$') | |
| return re.sub(r'\n{3,}', '\n\n', s).strip() | |
| def layout_only(text): | |
| """Recognize complete fragments containing only pagination/bibliography UI.""" | |
| text = re.sub(r'\\(?:clearpage|newpage|pagebreak|nobreak|small|footnotesize|scriptsize|normalsize|appendix|phantomsection|par|noindent|bigskip|medskip|smallskip|begingroup|endgroup|centering|raggedright)\b(?:\[[^\]]*\])?', '', text) | |
| text = re.sub(r'\\Needspace\s*\{[^{}]*\}', '', text) | |
| text = re.sub(r'\\addcontentsline\s*\{toc\}\s*\{section\}\s*\{(?:References|\\refname)\}', '', text) | |
| text = re.sub(r'\\pdfbookmark(?:\[[^\]]*\])?\s*\{References\}\s*\{references\}', '', text) | |
| for match in list(re.finditer(r'\\renewcommand\s*', text))[::-1]: | |
| try: | |
| a, end = args_at(text, match.end(), 2) | |
| except ValueError: | |
| continue | |
| if a[0] == '\\bibsection': | |
| text = text[:match.start()] + text[end:] | |
| return not text.strip(' \t\n{}') | |
| class Corpus: | |
| def __init__(self, root, output, chunk_chars, preserve_worker_inputs=False): | |
| self.root = root.resolve() | |
| self.output = output | |
| self.chunk_chars = chunk_chars | |
| self.preserve_worker_inputs = preserve_worker_inputs | |
| self.commit = subprocess.check_output(['git', '-C', str(root), 'rev-parse', 'HEAD'], text=True).strip() | |
| self.files = {} | |
| self.read_cache = {} | |
| self.extraction = [] | |
| self.macros = [] | |
| def rel(self, p): | |
| return str(p.resolve().relative_to(self.root)) | |
| def source(self, p): | |
| p = p.resolve() | |
| p.relative_to(self.root) | |
| key = self.rel(p) | |
| if key not in self.files: | |
| self.files[key] = {'path': key, 'sha256': digest(p), 'bytes': p.stat().st_size, | |
| 'source_url': f'{REPO_URL}/blob/{self.commit}/{quote(key, safe="/") }'} | |
| return self.files[key] | |
| def read(self, p): | |
| p = p.resolve() | |
| if p not in self.read_cache: | |
| self.read_cache[p] = p.read_text(errors='replace') | |
| return self.read_cache[p] | |
| def catalog(self): | |
| overview = uncomment(self.read(self.root / 'overview.tex')).split('\\begin{document}', 1)[1] | |
| family_meta, current, subject = {}, {}, None | |
| for m in re.finditer(r'\\(cataloguesection|resultentry)\b', overview): | |
| if m.group(1) == 'cataloguesection': | |
| a, _ = args_at(overview, m.end(), 2) | |
| subject = a[0] | |
| else: | |
| a, _ = args_at(overview, m.end(), 4) | |
| fid, family_title, family_summary, refs = a | |
| family_meta[fid] = {'family_id': fid, 'title': family_title, 'source_claim_summary': family_summary, 'discipline': subject} | |
| for href in re.finditer(r'\\href\b', refs): | |
| values, _ = args_at(refs, href.end(), 2) | |
| url, title = values | |
| if '/preprints/' not in url or not url.endswith('.pdf'): | |
| continue | |
| pdf_path = 'preprints/' + unquote(url.split('/preprints/', 1)[1]) | |
| paper_id = Path(pdf_path).parts[1] | |
| meta = current.setdefault(paper_id, {'paper_id': paper_id, 'title': title, 'pdf_path': pdf_path, 'family_ids': [], 'disciplines': []}) | |
| if fid not in meta['family_ids']: | |
| meta['family_ids'].append(fid) | |
| if subject not in meta['disciplines']: | |
| meta['disciplines'].append(subject) | |
| # CONTENTS paths may contain literal parentheses: delimit at the final .pdf). | |
| contents = self.read(self.root / 'CONTENTS.md') | |
| paper_re = re.compile(r' \[([^\n]*)\]\((preprints/[^\n]+\.pdf)\)[^\n]*\n(.*?)(?=</td>)', re.S) | |
| map_paths = set() | |
| for match in paper_re.finditer(contents): | |
| title, pdf_path, abstract = match.groups() | |
| # Title is non-newline; abstract greediness is limited by its first closing cell. | |
| pdf_path = unquote(pdf_path) | |
| paper_id = Path(pdf_path).parts[1] | |
| if paper_id not in current: | |
| raise ValueError('CONTENTS paper absent from overview: ' + paper_id) | |
| current[paper_id]['title'] = clean_html(title) | |
| current[paper_id]['abstract'] = clean_html(abstract) | |
| current[paper_id]['contents_abstract_source'] = 'CONTENTS.md' | |
| map_paths.add(pdf_path) | |
| if len(current) != 721 or len(map_paths) != 721 or len(family_meta) != 373: | |
| raise ValueError(f'Unexpected catalog coverage current={len(current)}, CONTENTS={len(map_paths)}, families={len(family_meta)}') | |
| if any(not x.get('abstract') for x in current.values()): | |
| raise ValueError('Missing abstract') | |
| previous_to_current = collections.defaultdict(set) | |
| for d in sorted((self.root / 'preprints').iterdir()): | |
| if not d.is_dir(): | |
| continue | |
| md = self.read(d / 'README.md') | |
| for m in re.finditer(r'\[previous version\]\(([^\n]+?\.pdf)\)', md, re.I): | |
| target = (d / unquote(m.group(1))).resolve() | |
| target.relative_to(self.root) | |
| previous_to_current[target.parent.name].add(d.name) | |
| # Transitive closure links older versions to the current catalog. | |
| def successors(pid, seen=None): | |
| seen = set() if seen is None else set(seen) | |
| if pid in seen: | |
| return set() | |
| if pid in current: | |
| return {pid} | |
| seen.add(pid) | |
| return set().union(*(successors(x, seen) for x in previous_to_current.get(pid, []))) if previous_to_current.get(pid) else set() | |
| manuscripts = [] | |
| for d in sorted((self.root / 'preprints').iterdir()): | |
| if not d.is_dir(): | |
| continue | |
| pdfs = sorted(d.glob('*.pdf')) | |
| if len(pdfs) != 1: | |
| raise ValueError('Expected single top-level manuscript PDF: ' + d.name) | |
| pid = d.name | |
| readme = self.read(d / 'README.md') | |
| title_m = re.search(r'^#\s*\[(.*)\]\([^\n]+\.pdf\)', readme, re.M) | |
| title = title_m.group(1) if title_m else pid | |
| succ = successors(pid) if pid not in current else {pid} | |
| status = 'current' if pid in current else ('previous' if pid in previous_to_current else 'withdrawn') | |
| meta = dict(current.get(pid, {})) | |
| meta.update(paper_id=pid, title=meta.get('title', title), status=status, pdf_path=self.rel(pdfs[0]), | |
| license=LICENSE, creators=['OpenAI'], source_commit=self.commit, | |
| verification_status='unverified_source_claim', lean_verified=False, | |
| current_versions=sorted(succ), previous_versions=sorted(k for k in previous_to_current if pid in previous_to_current[k]), | |
| citation_bibtex=(re.search(r'```bibtex\s*\n(.*?)```', readme, re.S).group(1).strip() if re.search(r'```bibtex\s*\n(.*?)```', readme, re.S) else None), | |
| readme_source=self.source(d / 'README.md'), pdf_source=self.source(pdfs[0])) | |
| if status == 'withdrawn' and 'withdraw' not in readme.lower(): | |
| raise ValueError('Uncatalogued directory is not documented withdrawn: ' + pid) | |
| if status == 'previous': | |
| meta['family_ids'] = sorted(set(f for x in succ for f in current[x]['family_ids'])) | |
| meta['disciplines'] = sorted(set(f for x in succ for f in current[x]['disciplines'])) | |
| meta.setdefault('family_ids', []) | |
| meta.setdefault('disciplines', []) | |
| meta['family_id'] = meta['family_ids'][0] if meta['family_ids'] else None | |
| meta['discipline'] = meta['disciplines'][0] if meta['disciplines'] else None | |
| meta['formalization_artifact_present'] = any((self.root / 'lean' / 'docs' / (f + '.md')).exists() for f in meta['family_ids']) | |
| meta['formalization_scope_docs'] = [self.rel(self.root / 'lean' / 'docs' / (f + '.md')) for f in meta['family_ids'] if (self.root / 'lean' / 'docs' / (f + '.md')).exists()] | |
| manuscripts.append(meta) | |
| # Families shared by a paper must remain in a single split. | |
| parent = {f: f for f in family_meta} | |
| def find(f): | |
| while parent[f] != f: | |
| parent[f] = parent[parent[f]] | |
| f = parent[f] | |
| return f | |
| for meta in current.values(): | |
| for f in meta['family_ids'][1:]: | |
| a, b = find(meta['family_ids'][0]), find(f) | |
| parent[max(a, b)] = min(a, b) | |
| for meta in manuscripts: | |
| meta['group'] = 'openai-math:family:' + find(meta['family_ids'][0]) if meta['family_ids'] else 'openai-math:withdrawn:' + meta['paper_id'] | |
| return manuscripts, family_meta | |
| def select_main(self, paper): | |
| candidates = [] | |
| roots = [] | |
| for p in sorted(paper.rglob('*.tex')): | |
| if p.is_symlink() or any(x in {'tools', 'provenance', '.git'} for x in p.relative_to(paper).parts): | |
| continue | |
| text = uncomment(self.read(p)) | |
| if '\\begin{document}' not in text: | |
| continue | |
| roots.append(p) | |
| rel = str(p.relative_to(paper)) | |
| score = 100 if p.name == 'main.tex' else (90 if p.name == 'paper.tex' else 50) | |
| score -= len(p.relative_to(paper).parts) * 2 | |
| if 'figure' in rel.lower(): | |
| score -= 100 | |
| score += min(len(text) / 1000000, 1) | |
| candidates.append((score, p)) | |
| if not candidates: | |
| raise ValueError('No main TeX with document body: ' + paper.name) | |
| candidates.sort(key=lambda x: (-x[0], str(x[1]))) | |
| return candidates[0][1], roots | |
| def extract(self, meta): | |
| paper = self.root / 'preprints' / meta['paper_id'] | |
| main, candidates = self.select_main(paper) | |
| dependencies, unresolved, exclusions, preambles, distribution_dependencies, listings = {}, [], [], [], [], [] | |
| active, expanded = set(), [] | |
| def exclude(path, start, end, reason): | |
| if end >= start: | |
| exclusions.append({'source_path': self.rel(path), 'start_line': start, 'end_line': end, 'reason': reason}) | |
| def resolve(name, source, text_attachment=False): | |
| if any(c in name for c in '\\#{}'): | |
| return None | |
| for base in (source.parent, main.parent, paper / 'build', paper): | |
| p = (base / name).resolve() | |
| try: | |
| p.relative_to(self.root) | |
| except ValueError: | |
| continue | |
| options = [p] if p.suffix == '.tex' else [p, p.with_name(p.name + '.tex')] | |
| for opt in options: | |
| if opt.is_file() and (text_attachment or opt.suffix in {'.tex', '.tikz'}): | |
| return opt | |
| return None | |
| include_re = re.compile(r'\\(input|include|subfile)(?![A-Za-z@])\s*(?:\{([^{}]+)\}|([^\s%{}]+))|\\includepdf(?:\[[^\n]*?\])?\s*\{([^{}]+)\}') | |
| def expand(path, context='body'): | |
| path = path.resolve() | |
| path.relative_to(self.root) | |
| if path in active: | |
| unresolved.append({'source_path': self.rel(path), 'reason': 'cyclic_include'}) | |
| return [] | |
| active.add(path) | |
| dependencies[self.rel(path)] = self.source(path) | |
| original = self.read(path) | |
| text = uncomment(original) | |
| lines = text.splitlines(keepends=True) | |
| begin = next((i for i, line in enumerate(lines) if '\\begin{document}' in line), None) | |
| if begin is not None: | |
| raw_pre = ''.join(lines[:begin]) | |
| preambles.append({'source_path': self.rel(path), 'source_sha256': digest(path), 'start_line': 1, 'end_line': begin, 'text': raw_pre}) | |
| exclude(path, 1, begin, 'preamble_preserved_in_macro_context') | |
| # Expand preamble includes into sidecar, never inject them into body. | |
| for i, line in enumerate(lines[:begin], 1): | |
| for m in include_re.finditer(line): | |
| name = m.group(2) or m.group(3) | |
| if not name: | |
| continue | |
| dep = resolve(name, path) | |
| if dep is None: | |
| (distribution_dependencies if Path(name).name.startswith('glyphtounicode') else unresolved).append({'source_path': self.rel(path), 'line': i, 'target': name, 'reason': 'non_content_tex_distribution_dependency' if Path(name).name.startswith('glyphtounicode') else 'unresolved_preamble_include'}) | |
| else: | |
| preambles.extend(expand(dep, context='preamble')) | |
| line = lines[begin] | |
| lines[begin] = line.split('\\begin{document}', 1)[1] | |
| if context == 'preamble': | |
| contexts = [{'source_path': self.rel(path), 'source_sha256': digest(path), 'start_line': 1, 'end_line': len(lines), 'text': text}] | |
| if begin is None: | |
| for i, line in enumerate(lines, 1): | |
| for m in include_re.finditer(line): | |
| name = m.group(2) or m.group(3) | |
| if not name: | |
| continue | |
| dep = resolve(name, path) | |
| if dep is None: | |
| target = distribution_dependencies if Path(name).name.startswith('glyphtounicode') else unresolved | |
| target.append({'source_path': self.rel(path), 'line': i, 'target': name, 'reason': 'non_content_tex_distribution_dependency' if Path(name).name.startswith('glyphtounicode') else 'unresolved_preamble_include'}) | |
| else: | |
| contexts.extend(expand(dep, context='preamble')) | |
| active.remove(path) | |
| return contexts | |
| output = [] | |
| skip_env = None | |
| skip_start = None | |
| verbatim = None | |
| consumed_listing_until = -1 | |
| first = begin or 0 | |
| for i in range(first, len(lines)): | |
| line, lineno = lines[i], i + 1 | |
| if i <= consumed_listing_until: | |
| continue | |
| if verbatim: | |
| output.append((line, self.rel(path), lineno)) | |
| if '\\end{' + verbatim + '}' in line: | |
| verbatim = None | |
| continue | |
| verbatim_start = re.search(r'\\begin\{(lstlisting|verbatim|Verbatim|minted)\}', line) | |
| if verbatim_start: | |
| output.append((line, self.rel(path), lineno)) | |
| if '\\end{' + verbatim_start.group(1) + '}' not in line[verbatim_start.end():]: | |
| verbatim = verbatim_start.group(1) | |
| continue | |
| if '\\end{document}' in line: | |
| before = line.split('\\end{document}', 1)[0] | |
| if before.strip(): | |
| output.append((before, self.rel(path), lineno)) | |
| exclude(path, lineno, len(lines), 'end_document_and_trailing_material') | |
| break | |
| if skip_env: | |
| if '\\end{' + skip_env + '}' in line: | |
| exclude(path, skip_start, lineno, 'bibliography' if skip_env == 'thebibliography' else 'pure_drawing_code') | |
| skip_env = None | |
| continue | |
| env_m = re.search(r'\\begin\{(thebibliography|tikzpicture|axis|asy|pspicture|pgfonlayer)\}', line) | |
| if env_m: | |
| env = env_m.group(1) | |
| prefix = line[:env_m.start()] | |
| if prefix.strip(): | |
| output.append((prefix, self.rel(path), lineno)) | |
| end_token = '\\end{' + env + '}' | |
| if end_token in line[env_m.end():]: | |
| rest = line.split(end_token, 1)[1] | |
| if rest.strip(): | |
| output.append((rest, self.rel(path), lineno)) | |
| exclude(path, lineno, lineno, 'bibliography' if env == 'thebibliography' else 'pure_drawing_code') | |
| else: | |
| skip_env, skip_start = env, lineno | |
| continue | |
| if re.match(r'\s*\\(?:bibliography|bibliographystyle|printbibliography|addbibresource|maketitle|tableofcontents|listoffigures|listoftables)\b', line): | |
| exclude(path, lineno, lineno, 'bibliography_or_layout_command') | |
| continue | |
| listing_start = re.search(r'\\(lstinputlisting|verbatiminput|VerbatimInput|inputminted)(?![A-Za-z@])', line) | |
| if listing_start: | |
| # These commands insert literal source/verification data into | |
| # the PDF. Read the requested file as data; never execute it. | |
| following = ''.join(lines[i:]) | |
| pos = listing_start.end() | |
| while pos < len(following) and following[pos].isspace(): | |
| pos += 1 | |
| options = '' | |
| if following[pos:pos + 1] == '[': | |
| depth, start_option = 1, pos + 1 | |
| pos += 1 | |
| while pos < len(following) and depth: | |
| if following[pos] == '[': | |
| depth += 1 | |
| elif following[pos] == ']': | |
| depth -= 1 | |
| pos += 1 | |
| options = following[start_option:pos - 1] | |
| try: | |
| if listing_start.group(1) == 'inputminted': | |
| _, pos = group_at(following, pos) | |
| target_name, end = group_at(following, pos) | |
| except ValueError: | |
| unresolved.append({'source_path': self.rel(path), 'line': lineno, 'reason': 'unparsed_external_code_listing'}) | |
| else: | |
| command_text = following[listing_start.start():end] | |
| command_lines = following[:end].count('\n') | |
| consumed_listing_until = i + command_lines | |
| dep = resolve(target_name, path, text_attachment=True) | |
| relocated_by_checksum = False | |
| if dep is None: | |
| # One release retained an old certificate/ listing | |
| # path after moving the file to verification/. Accept | |
| # the moved source only when the manuscript itself | |
| # prints its exact SHA256, including TeX line wraps. | |
| relocated = paper / 'verification' / Path(target_name).name | |
| if relocated.is_file(): | |
| manuscript_checksum_text = re.sub(r'\s+|\\allowbreak', '', self.read(main)) | |
| if digest(relocated) in manuscript_checksum_text: | |
| dep, relocated_by_checksum = relocated.resolve(), True | |
| if line[:listing_start.start()].strip(): | |
| output.append((line[:listing_start.start()], self.rel(path), lineno)) | |
| if dep is None: | |
| unresolved.append({'source_path': self.rel(path), 'line': lineno, 'target': target_name, 'reason': 'external_code_listing_not_found'}) | |
| output.append((command_text + '\n', self.rel(path), lineno)) | |
| else: | |
| dependencies[self.rel(dep)] = self.source(dep) | |
| literal_lines = self.read(dep).splitlines(keepends=True) | |
| first_line = re.search(r'\bfirstline\s*=\s*(\d+)', options) | |
| last_line = re.search(r'\blastline\s*=\s*(\d+)', options) | |
| a = int(first_line.group(1)) if first_line else 1 | |
| b = int(last_line.group(1)) if last_line else len(literal_lines) | |
| output.append(('\\begin{lstlisting}' + ('[' + options + ']' if options else '') + '\n', self.rel(path), lineno)) | |
| for n, literal_line in enumerate(literal_lines[a - 1:b], a): | |
| output.append((literal_line if literal_line.endswith('\n') else literal_line + '\n', self.rel(dep), n)) | |
| output.append(('\\end{lstlisting}\n', self.rel(path), lineno + command_lines)) | |
| listings.append({'from': self.rel(path), 'start_line': lineno, 'end_line': lineno + command_lines, | |
| 'target': self.rel(dep), 'target_sha256': self.source(dep)['sha256'], | |
| 'declared_target': target_name, 'relocated_by_matching_manuscript_sha256': relocated_by_checksum, | |
| 'target_start_line': a, 'target_end_line': b, 'mode': 'literal_read_only_not_executed'}) | |
| suffix = following[end:].split('\n', 1)[0] | |
| if suffix.strip(): | |
| output.append((suffix + '\n', self.rel(path), lineno + command_lines)) | |
| continue | |
| matches = list(include_re.finditer(line)) | |
| if not matches: | |
| if line.strip(): | |
| output.append((line, self.rel(path), lineno)) | |
| elif output and output[-1][0].strip(): | |
| output.append(('\n', self.rel(path), lineno)) | |
| continue | |
| last = 0 | |
| for m in matches: | |
| prefix = line[last:m.start()] | |
| if prefix.strip(): | |
| output.append((prefix, self.rel(path), lineno)) | |
| name = m.group(2) or m.group(3) or m.group(4) | |
| if m.group(4): | |
| name = str(Path(name).with_suffix('.tex')) | |
| dep = resolve(name, path) | |
| if dep is None: | |
| unresolved.append({'source_path': self.rel(path), 'line': lineno, 'target': name, 'reason': 'unresolved_pdf_tex' if m.group(4) else 'unresolved_include'}) | |
| output.append((m.group(0), self.rel(path), lineno)) | |
| elif dep.suffix == '.tikz': | |
| dependencies[self.rel(dep)] = self.source(dep) | |
| exclude(dep, 1, len(self.read(dep).splitlines()), 'pure_drawing_include') | |
| elif dep.stem.lower() in {'references', 'bibliography'} or dep.parent.name.lower() in {'references', 'bibliography'}: | |
| dependencies[self.rel(dep)] = self.source(dep) | |
| exclude(dep, 1, len(self.read(dep).splitlines()), 'bibliography_include') | |
| else: | |
| expanded.append({'from': self.rel(path), 'line': lineno, 'target': self.rel(dep), 'kind': 'includepdf_tex_counterpart' if m.group(4) else m.group(1)}) | |
| output.extend(expand(dep)) | |
| last = m.end() | |
| rest = line[last:] | |
| if rest.strip(): | |
| output.append((rest, self.rel(path), lineno)) | |
| if skip_env: | |
| exclude(path, skip_start, len(lines), 'unterminated_' + skip_env) | |
| unresolved.append({'source_path': self.rel(path), 'reason': 'unterminated_skipped_environment', 'environment': skip_env}) | |
| active.remove(path) | |
| return output | |
| tape = expand(main) | |
| macro_key = 'macro:' + meta['paper_id'] | |
| macro_context = {'id': macro_key, 'paper_id': meta['paper_id'], 'group': meta['group'], 'license': LICENSE, 'contexts': preambles} | |
| self.macros.append(macro_context) | |
| full = ''.join(x[0] for x in tape).strip() | |
| if len(full) < 500: | |
| raise ValueError('Implausibly short extracted body: ' + meta['paper_id']) | |
| section_re = re.compile(r'\\(?:part|chapter|section|subsection)\*?(?:\[[^\]]*\])?\s*\{') | |
| section_titles = [] | |
| for m in section_re.finditer(full): | |
| try: | |
| section_titles.append(group_at(full, m.end() - 1)[0]) | |
| except ValueError: | |
| pass | |
| # Split only at paragraph/section boundaries outside mathematical and proof | |
| # environments, display math and brace groups. The target is soft: retain a | |
| # long proof as one record rather than truncate its assumptions or argument. | |
| chunks, chunk, size, section = [], [], 0, 'Front matter and abstract' | |
| chunk_section, environments = section, [] | |
| display_math, brace_depth, safe_boundary = None, 0, True | |
| env_re = re.compile(r'\\(begin|end)\{([^}]+)\}') | |
| for entry in tape: | |
| text_line = entry[0] | |
| sm = section_re.search(text_line) | |
| new_section = None | |
| if sm: | |
| try: | |
| new_section = group_at(text_line, sm.end() - 1)[0] | |
| except ValueError: | |
| pass | |
| outside = not environments and display_math is None and brace_depth == 0 | |
| if chunk and outside and ((new_section and size >= 800) or (size >= self.chunk_chars and safe_boundary)): | |
| chunks.append((chunk_section, chunk)) | |
| chunk, size = [], 0 | |
| chunk_section = new_section or section | |
| if new_section: | |
| section = new_section | |
| if not chunk: | |
| chunk_section = section | |
| chunk.append(entry) | |
| size += len(text_line) | |
| if environments and environments[-1] in {'lstlisting', 'verbatim', 'Verbatim', 'minted'}: | |
| if '\\end{' + environments[-1] + '}' in text_line: | |
| environments.pop() | |
| safe_boundary = True | |
| continue | |
| closed_env = False | |
| for event in env_re.finditer(text_line): | |
| kind, env = event.groups() | |
| if kind == 'begin': | |
| environments.append(env) | |
| elif env in environments: | |
| # Retain strict nesting when valid; malformed source is kept. | |
| if environments[-1] == env: | |
| environments.pop() | |
| else: | |
| environments.remove(env) | |
| closed_env = True | |
| for event in re.finditer(r'(?<!\\)(?:\\\[|\\\]|\$\$)', text_line): | |
| marker = event.group() | |
| if marker == r'\[': | |
| display_math = r'\[' | |
| elif marker == r'\]': | |
| display_math = None | |
| else: | |
| display_math = None if display_math == '$$' else '$$' | |
| for event in re.finditer(r'(?<!\\)[{}]', text_line): | |
| brace_depth += 1 if event.group() == '{' else -1 | |
| safe_boundary = not text_line.strip() or closed_env | |
| if chunk: | |
| chunks.append((chunk_section, chunk)) | |
| records = [] | |
| for n, (section, entries) in enumerate(chunks): | |
| text = ''.join(e[0] for e in entries).strip() | |
| if not text: | |
| continue | |
| if layout_only(text): | |
| for _, source_path, source_line in entries: | |
| exclude(self.root / source_path, source_line, source_line, 'layout_only_fragment') | |
| continue | |
| spans = [] | |
| for _, path, line in entries: | |
| if spans and spans[-1]['path'] == path and line <= spans[-1]['end_line'] + 1: | |
| spans[-1]['end_line'] = max(spans[-1]['end_line'], line) | |
| else: | |
| spans.append({'path': path, 'start_line': line, 'end_line': line, 'sha256': self.files[path]['sha256'], 'source_url': self.files[path]['source_url']}) | |
| records.append({'id': f'openai-math:{meta["paper_id"]}:{n:04d}', 'paper_id': meta['paper_id'], 'title': meta['title'], | |
| 'text': text, 'section': section, 'record_type': 'source_latex', 'group': meta['group'], 'license': LICENSE, | |
| 'creators': ['OpenAI'], 'family_id': meta['family_id'], 'family_ids': meta['family_ids'], 'discipline': meta['discipline'], | |
| 'source_commit': self.commit, 'source_path': self.rel(main), 'source_sha256': digest(main), | |
| 'source_url': self.source(main)['source_url'], 'source_spans': spans, 'macro_context_id': macro_key, | |
| 'verification_status': 'unverified_source_claim', 'lean_verified': False, 'transform': 'deterministic_latex_body_extraction', 'chunk_index': n, | |
| 'contains_code_listing': '\\begin{lstlisting}' in text or '\\begin{verbatim}' in text or '\\begin{minted}' in text}) | |
| snippets = [] | |
| statement_re = re.compile(r'\\begin\{(theorem|thm|proposition|prop|lemma|corollary|cor|conjecture)\*?\}') | |
| for m in statement_re.finditer(full): | |
| end = re.search(r'\\end\{' + re.escape(m.group(1)) + r'\*?\}', full[m.end():]) | |
| if end: | |
| snippets.append(full[m.start():m.end() + end.end()][:6000]) | |
| if len(snippets) >= 3: | |
| break | |
| flags = sorted(set(x['reason'] for x in unresolved)) | |
| if len(candidates) > 1: | |
| flags.append('multiple_document_roots_scored') | |
| worker = {'paper_id': meta['paper_id'], 'title': meta['title'], 'family_id': meta['family_id'], 'family_ids': meta['family_ids'], | |
| 'discipline': meta['discipline'], 'abstract': meta['abstract'], 'section_titles': section_titles, | |
| 'source_excerpt': full[:12000], 'main_statement_snippets': snippets, 'extraction_flags': flags, | |
| 'verification_status': 'unverified_source_claim', 'source_commit': self.commit, 'group': meta['group']} | |
| meta.update(main_tex_source=self.source(main), source_dependencies=list(dependencies.values()), body_characters=len(full), records=len(records), | |
| extraction_flags=flags, excluded_ranges=exclusions, unresolved_includes=unresolved, expanded_includes=expanded, | |
| main_tex_candidates=[self.rel(x) for x in candidates], macro_context_id=macro_key, tex_distribution_dependencies=distribution_dependencies, | |
| external_listings=listings) | |
| self.extraction.append({'paper_id': meta['paper_id'], 'main_tex_path': self.rel(main), 'body_characters': len(full), | |
| 'records': len(records), 'dependency_files': len(dependencies), 'unresolved_includes': unresolved, | |
| 'excluded_ranges': exclusions, 'extraction_flags': flags, 'tex_distribution_dependencies': distribution_dependencies, | |
| 'external_listings': listings}) | |
| return records, worker | |
| def build(self): | |
| self.output.mkdir(parents=True, exist_ok=True) | |
| manuscripts, families = self.catalog() | |
| records, workers = [], [] | |
| for n, meta in enumerate(manuscripts): | |
| if meta['status'] != 'current': | |
| continue | |
| extracted, worker = self.extract(meta) | |
| records.extend(extracted) | |
| workers.append(worker) | |
| counts = collections.Counter(m['status'] for m in manuscripts) | |
| if dict(counts) != {'current': 721, 'previous': 27, 'withdrawn': 3}: | |
| raise ValueError('Unexpected status counts: ' + str(counts)) | |
| assert len(workers) == 721 and {r['paper_id'] for r in records} == {w['paper_id'] for w in workers} | |
| for name in ['README.md', 'CONTENTS.md', 'overview.tex', 'history.md', 'LICENSE', 'lean/formalization.yaml']: | |
| self.source(self.root / name) | |
| jsonl(self.output / 'data/source-records.jsonl', records) | |
| jsonl(self.output / 'data/macro-contexts.jsonl', self.macros) | |
| worker_path = self.output / 'worker-inputs.jsonl' | |
| worker_differences = [] | |
| if self.preserve_worker_inputs and worker_path.exists(): | |
| jsonl(self.output / 'worker-inputs-improved.jsonl', workers) | |
| frozen_workers = {x['paper_id']: x for x in map(json.loads, worker_path.read_text().splitlines())} | |
| for final in workers: | |
| before = frozen_workers[final['paper_id']] | |
| changed_fields = [key for key in sorted(before.keys() | final.keys()) if before.get(key) != final.get(key)] | |
| if changed_fields: | |
| worker_differences.append({'paper_id': final['paper_id'], 'changed_fields': changed_fields, | |
| 'before_flags': before['extraction_flags'], 'final_flags': final['extraction_flags'], | |
| 'source_excerpt_changed': before['source_excerpt'] != final['source_excerpt'], | |
| 'statement_snippets_changed': before['main_statement_snippets'] != final['main_statement_snippets']}) | |
| else: | |
| jsonl(worker_path, workers) | |
| jsonl(self.output / 'audit/worker-input-differences.jsonl', worker_differences) | |
| jsonl(self.output / 'audit/manuscripts.jsonl', manuscripts) | |
| jsonl(self.output / 'audit/extraction.jsonl', self.extraction) | |
| jsonl(self.output / 'audit/source-files.jsonl', sorted(self.files.values(), key=lambda x: x['path'])) | |
| dump(self.output / 'audit/families.json', families) | |
| report = {'source_commit': self.commit, 'manuscript_status_counts': dict(counts), 'family_count': len(families), | |
| 'disciplines': sorted(set(f['discipline'] for f in families.values())), 'source_records': len(records), | |
| 'source_papers': len(workers), 'source_body_characters': sum(m.get('body_characters', 0) for m in manuscripts), | |
| 'source_dependency_files': len(self.files), 'macro_contexts': len(self.macros), | |
| 'worker_inputs_sha256': digest(worker_path), | |
| 'worker_inputs_preserved': self.preserve_worker_inputs, | |
| 'worker_input_snapshot_changed_papers': len(worker_differences), | |
| 'worker_input_excerpt_changed_papers': sum(x['source_excerpt_changed'] for x in worker_differences), | |
| 'worker_input_statement_changed_papers': sum(x['statement_snippets_changed'] for x in worker_differences), | |
| 'worker_input_snapshot_note': 'Workers review the immutable worker-inputs.jsonl snapshot when --preserve-worker-inputs is used. Final extraction differences are recorded in audit/worker-input-differences.jsonl. Worker annotations describe abstracts and supplied excerpts, not a mathematical audit of entire manuscripts.', | |
| 'tex_distribution_dependency_count': sum(len(x['tex_distribution_dependencies']) for x in self.extraction), | |
| 'external_literal_listing_count': sum(len(x['external_listings']) for x in self.extraction), | |
| 'unresolved_includes_count': sum(len(x['unresolved_includes']) for x in self.extraction), | |
| 'papers_with_unresolved_includes': [x['paper_id'] for x in self.extraction if x['unresolved_includes']], | |
| 'policies': ['Only current catalog manuscripts enter source-records.', 'Text is source LaTeX, not model-generated proofs.', | |
| 'Preamble is preserved in macro-contexts.jsonl; comments, bibliography, layout-only commands and drawing environments excluded.', | |
| 'Local input/include/subfile are read recursively; includepdf uses same-name TeX counterpart when present.', | |
| 'Root TeX scored by conventional main/paper filename, location and body presence; candidates retained in audit.', | |
| 'Source line spans are coarse ranges across comment removal; exact source hashes and retained text are recorded.', | |
| 'No TeX, shell commands, model prompts, or embedded build instructions from source documents are executed.', | |
| 'No Lean compilation performed; all mathematical claims remain unverified_source_claim.', | |
| 'Groups join result families sharing a manuscript to prevent split leakage.', | |
| 'Chunk target is soft: proofs, math environments, display math and brace groups are not cut at arbitrary length.', | |
| 'External lstinputlisting/verbatiminput/VerbatimInput/inputminted data is read literally, never executed; exact attachment hashes and line ranges are audited.', | |
| 'Pure layout fragments are excluded and recorded in excluded_ranges.', | |
| 'worker-inputs.jsonl is an immutable worker-review snapshot when --preserve-worker-inputs is used; worker-inputs-improved.jsonl contains final extraction flags and excerpts.']} | |
| dump(self.output / 'extraction-report.json', report) | |
| print(json.dumps(report, ensure_ascii=False)) | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument('--source', type=Path, default=Path('/Users/zxy/math')) | |
| ap.add_argument('--output', type=Path, default=Path('work/staging/openai-math')) | |
| ap.add_argument('--chunk-chars', type=int, default=8000) | |
| ap.add_argument('--preserve-worker-inputs', action='store_true') | |
| args = ap.parse_args() | |
| Corpus(args.source, args.output, args.chunk_chars, args.preserve_worker_inputs).build() | |
| if __name__ == '__main__': | |
| main() | |