Datasets:
Download components/openai-math/tools/finalize_openai_math.py from MMLA-ORG/Cayley-Math: direct link, hf CLI and curl.
- Browser
- Download file 28.9 kB
-
https://huggingface.co/datasets/MMLA-ORG/Cayley-Math/resolve/refs%2Fpr%2F8/components/openai-math/tools/finalize_openai_math.py
- Command line
-
hf download hf://datasets/MMLA-ORG/Cayley-Math@refs/pr/8/components/openai-math/tools/finalize_openai_math.py
-
curl -L -o finalize_openai_math.py https://huggingface.co/datasets/MMLA-ORG/Cayley-Math/resolve/refs%2Fpr%2F8/components/openai-math/tools/finalize_openai_math.py
28.9 kB
| #!/usr/bin/env python3 | |
| """Finalize the independently versioned OpenAI Math contribution.""" | |
| from __future__ import annotations | |
| import argparse | |
| from collections import Counter, deque | |
| import gzip | |
| import hashlib | |
| import json | |
| import math | |
| from pathlib import Path | |
| import shutil | |
| import subprocess | |
| MODEL = 'deepseek-v4.1-flash' | |
| COMMIT = '4eaee87548250b2682affda7d05d947c05554bae' | |
| CORE = ('id', 'text', 'group', 'license', 'paper_id', 'split', 'record_type', 'source_url') | |
| SPLITS = ('train', 'dev', 'test') | |
| def canonical(value): | |
| return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':')) | |
| def sha(path): | |
| h = hashlib.sha256() | |
| with Path(path).open('rb') as f: | |
| for chunk in iter(lambda: f.read(1024 * 1024), b''): | |
| h.update(chunk) | |
| return h.hexdigest() | |
| def read_jsonl(path): | |
| path = Path(path) | |
| opener = gzip.open if path.suffix == '.gz' else open | |
| with opener(path, 'rt', encoding='utf-8') as f: | |
| for line in f: | |
| if line.strip(): | |
| yield json.loads(line) | |
| def write_json(path, obj): | |
| Path(path).parent.mkdir(parents=True, exist_ok=True) | |
| Path(path).write_text(json.dumps(obj, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') | |
| def write_jsonl(path, rows): | |
| path = Path(path) | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| if path.suffix == '.gz': | |
| with path.open('wb') as raw, gzip.GzipFile(filename='', mode='wb', fileobj=raw, mtime=0) as gz: | |
| for row in rows: | |
| gz.write((canonical(row) + '\n').encode('utf-8')) | |
| else: | |
| with path.open('w', encoding='utf-8') as f: | |
| for row in rows: | |
| f.write(canonical(row) + '\n') | |
| def paper_id(row): | |
| value = row.get('paper_id') or row.get('slug') or row.get('manuscript_id') | |
| if not value: | |
| raise ValueError('Record lacks paper_id/slug/manuscript_id') | |
| return value | |
| def write_parquet(path, rows): | |
| import pyarrow as pa | |
| import pyarrow.parquet as pq | |
| columns = {key: [str(row.get(key) or '') for row in rows] for key in CORE} | |
| columns['metadata_json'] = [canonical({k: v for k, v in row.items() if k not in CORE}) for row in rows] | |
| schema = pa.schema([(key, pa.string()) for key in (*CORE, 'metadata_json')]) | |
| pq.write_table(pa.Table.from_pydict(columns, schema=schema), path, compression='zstd', row_group_size=1024) | |
| def split_groups(groups): | |
| ordered = sorted(groups, key=lambda g: (hashlib.sha256(g.encode()).hexdigest(), g)) | |
| if len(ordered) < 3: | |
| raise ValueError('Need at least 3 family groups for nonempty leakage-safe splits') | |
| holdout = max(1, math.ceil(len(ordered) * .01)) | |
| if 2 * holdout >= len(ordered): | |
| holdout = 1 | |
| return {g: ('dev' if i < holdout else 'test' if i < 2 * holdout else 'train') for i, g in enumerate(ordered)} | |
| def pack_split(root, split, records, sp, seq_len=2048, shard_rows=256): | |
| import numpy as np | |
| packed = root / 'packed' | |
| packed.mkdir(exist_ok=True) | |
| shard_entries, pending_rows, pending_labels, pending_attrs = [], [], [], [] | |
| buffer, docs, stream_start, total_tokens, label_count, row_number = [], deque(), 0, 0, 0, 0 | |
| attr_file = (packed / f'{split}-rows.jsonl').open('w', encoding='utf-8') | |
| token_file = (packed / f'{split}-records.jsonl').open('w', encoding='utf-8') | |
| def flush(): | |
| nonlocal pending_rows, pending_labels, pending_attrs | |
| if not pending_rows: | |
| return | |
| shard = len(shard_entries) | |
| fields = {} | |
| arrays = {'input_ids': np.asarray(pending_rows, dtype=np.int32), | |
| 'labels': np.asarray(pending_labels, dtype=np.int32), | |
| 'role_ids': np.zeros((len(pending_rows), seq_len), dtype=np.int32)} | |
| for name, array in arrays.items(): | |
| path = packed / f'{split}-{shard:06d}-{name}.npy' | |
| np.save(path, array, allow_pickle=False) | |
| fields[name] = {'path': path.name, 'sha256': sha(path), 'bytes': path.stat().st_size, | |
| 'dtype': 'int32', 'shape': list(array.shape)} | |
| shard_entries.append({'count': len(pending_rows), 'fields': fields}) | |
| for index, attr in enumerate(pending_attrs): | |
| attr.update(shard=shard, shard_row=index) | |
| attr_file.write(canonical(attr) + '\n') | |
| pending_rows, pending_labels, pending_attrs = [], [], [] | |
| def emit(): | |
| nonlocal buffer, stream_start, label_count, row_number | |
| n = min(seq_len, len(buffer)) | |
| values = buffer[:n] | |
| targets = buffer[1:min(n + 1, len(buffer))] | |
| if len(targets) < n: | |
| targets.append(-100) | |
| targets = [-100 if t == 1 else t for t in targets] | |
| label_count += sum(t != -100 for t in targets) | |
| pending_rows.append(values + [0] * (seq_len - n)) | |
| pending_labels.append(targets + [-100] * (seq_len - n)) | |
| stop = stream_start + n | |
| spans = [] | |
| for doc in docs: | |
| lo, hi = max(stream_start, doc['start']), min(stop, doc['end']) | |
| if lo < hi: | |
| spans.append({'record_id': doc['id'], 'paper_id': doc['paper_id'], | |
| 'row_start': lo - stream_start, 'row_end': hi - stream_start, | |
| 'record_start': lo - doc['start'], 'record_end': hi - doc['start']}) | |
| pending_attrs.append({'row': row_number, 'stream_start': stream_start, 'length': n, 'segments': spans}) | |
| row_number += 1 | |
| stream_start = stop | |
| del buffer[:n] | |
| while docs and docs[0]['end'] <= stream_start: | |
| docs.popleft() | |
| if len(pending_rows) == shard_rows: | |
| flush() | |
| for record in records: | |
| tokens = [1] + sp.encode(record['text'], out_type=int) + [2] | |
| array = np.asarray(tokens, dtype='<i4') | |
| token_file.write(canonical({'id': record['id'], 'paper_id': record['paper_id'], 'tokens': len(tokens), | |
| 'token_sha256': hashlib.sha256(array.tobytes()).hexdigest()}) + '\n') | |
| docs.append({'id': record['id'], 'paper_id': record['paper_id'], 'start': total_tokens, 'end': total_tokens + len(tokens)}) | |
| total_tokens += len(tokens) | |
| buffer.extend(tokens) | |
| while len(buffer) >= seq_len + 1: | |
| emit() | |
| if buffer: | |
| emit() | |
| flush() | |
| attr_file.close() | |
| token_file.close() | |
| return shard_entries, {'rows': row_number, 'tokens': total_tokens, 'loss_bearing_labels': label_count} | |
| def write_manifest(root): | |
| entries = [] | |
| for path in sorted(root.rglob('*')): | |
| relative = path.relative_to(root).as_posix() | |
| if path.is_file() and relative not in {'manifest.json', 'validation.json'} and '.tmp' not in path.name: | |
| entries.append({'path': relative, 'bytes': path.stat().st_size, 'sha256': sha(path)}) | |
| write_json(root / 'manifest.json', {'format': 'cayley-contribution-file-manifest-v1', | |
| 'excludes': ['manifest.json', 'validation.json'], 'files': entries}) | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument('--component', type=Path, default=Path('work/staging/openai-math')) | |
| parser.add_argument('--workers', type=Path, default=Path('work/worker-results/papers.jsonl')) | |
| parser.add_argument('--worker-log-root', type=Path, help='Root against which worker log_path resolves') | |
| parser.add_argument('--source-root', type=Path, default=Path('/Users/zxy/math')) | |
| parser.add_argument('--tokenizer', type=Path, default=Path('/Users/zxy/Cayley-Math/tokenizer/tokenizer.model')) | |
| parser.add_argument('--expected-papers', type=int, default=721) | |
| parser.add_argument('--pack', action='store_true') | |
| args = parser.parse_args() | |
| root = args.component.resolve() | |
| originals = list(read_jsonl(root / 'data/source-records.jsonl')) | |
| if any(r.get('source_commit') != COMMIT for r in originals): | |
| raise ValueError('Source record revision differs from fixed source commit') | |
| manuscripts = list(read_jsonl(root / 'audit/manuscripts.jsonl')) | |
| if any(r.get('source_commit') != COMMIT for r in manuscripts): | |
| raise ValueError('Manuscript inventory revision differs from fixed source commit') | |
| live_commit = subprocess.check_output(['git', '-C', str(args.source_root), 'rev-parse', 'HEAD'], text=True).strip() | |
| if live_commit != COMMIT: | |
| raise ValueError('Local upstream checkout revision differs from fixed source commit') | |
| inputs = list(read_jsonl(root / 'worker-inputs.jsonl')) | |
| expected = {paper_id(x) for x in inputs} | |
| if len(expected) != args.expected_papers or len(inputs) != len(expected): | |
| raise ValueError(f'Expected {args.expected_papers} unique current papers; found {len(expected)}') | |
| workers = list(read_jsonl(args.workers)) | |
| by_paper = {paper_id(x): x for x in workers} | |
| if len(by_paper) != len(workers) or set(by_paper) != expected: | |
| raise ValueError(f'Worker coverage mismatch: missing={sorted(expected-set(by_paper))}; extra={sorted(set(by_paper)-expected)}') | |
| for worker in workers: | |
| if worker.get('model') != MODEL or worker.get('provider') != 'damn-grok' or worker.get('runner') != 'oh-my-pi' or worker.get('recommended_action') not in {'keep_source', 'needs_review'}: | |
| raise ValueError(f'Unexpected worker model/action: {paper_id(worker)}') | |
| if worker.get('review_scope') != 'abstract_headings_excerpt': | |
| raise ValueError(f'Unexpected review scope: {paper_id(worker)}') | |
| if not isinstance(worker.get('summary'), str) or not 80 <= len(worker['summary'].split()) <= 150: | |
| raise ValueError('Worker summary length outside 80-150 words') | |
| if not {'not_independently_verified', 'excerpt_review_only'} <= set(worker.get('quality_flags', [])): | |
| raise ValueError('Worker response lacks scope/verification flags') | |
| input_by_paper = {paper_id(r): r for r in inputs} | |
| current_manuscripts = {paper_id(r): r for r in manuscripts if r['status'] == 'current'} | |
| if set(current_manuscripts) != expected: | |
| raise ValueError('Current inventory and frozen worker input paper identities differ') | |
| for worker in workers: | |
| actual = hashlib.sha256(canonical(input_by_paper[paper_id(worker)]).encode()).hexdigest() | |
| if actual != worker.get('source_input_sha256'): | |
| raise ValueError('Worker individual input digest differs') | |
| groups = {r['group'] for r in originals} | |
| group_split = split_groups(groups) | |
| source_papers = {paper_id(r) for r in originals} | |
| if source_papers != expected: | |
| raise ValueError(f'Source coverage mismatch: missing={sorted(expected-source_papers)}; extra={sorted(source_papers-expected)}') | |
| records, duplicates, seen, ids, paper_groups = [], [], {}, set(), {} | |
| for index, row in enumerate(originals): | |
| record = dict(row) | |
| pid = paper_id(record) | |
| record['paper_id'] = pid | |
| record.setdefault('id', f'openai-math:{pid}:{index:06d}') | |
| record.setdefault('record_type', 'source_excerpt') | |
| record.setdefault('source_url', '') | |
| if not isinstance(record['text'], str) or not record['text'].strip() or not record.get('license'): | |
| raise ValueError(f'Empty text/license: {record["id"]}') | |
| if record['id'] in ids: | |
| raise ValueError(f'Duplicate source ID: {record["id"]}') | |
| ids.add(record['id']) | |
| if pid in paper_groups and paper_groups[pid] != record['group']: | |
| raise ValueError('Paper spans different groups') | |
| paper_groups[pid] = record['group'] | |
| record['split'] = group_split[record['group']] | |
| record['text_sha256'] = hashlib.sha256(record['text'].encode('utf-8')).hexdigest() | |
| record['worker_metadata'] = {k: by_paper[pid].get(k) for k in ('topics', 'quality_flags', 'recommended_action', 'review_scope')} | |
| record['worker_model'] = MODEL | |
| record['current_extraction_flags'] = list(current_manuscripts[pid].get('extraction_flags', [])) | |
| record['worker_observed_extraction_flags'] = list(input_by_paper[pid].get('extraction_flags', [])) | |
| record['worker_input_snapshot_differs_from_current'] = (record['current_extraction_flags'] != record['worker_observed_extraction_flags']) | |
| record['worker_snapshot_note'] = 'Worker metadata review used the frozen early extraction input; current extraction flags describe the final deterministic source extraction.' | |
| record['content_origin'] = 'source_extraction' | |
| record['mathematical_verification'] = 'not_performed' | |
| digest = record['text_sha256'] | |
| if digest in seen: | |
| duplicates.append({'excluded_id': record['id'], 'paper_id': pid, 'group': record['group'], | |
| 'kept_id': seen[digest]['id'], 'kept_group': seen[digest]['group'], 'text_sha256': digest}) | |
| continue | |
| seen[digest] = record | |
| records.append(record) | |
| if {r['paper_id'] for r in records} != expected: | |
| raise ValueError('Exact deduplication removed every source record of at least one paper') | |
| write_json(root / 'audit/group-splits.json', group_split) | |
| write_jsonl(root / 'audit/excluded-duplicates.jsonl', duplicates) | |
| split_counts = {} | |
| for split in SPLITS: | |
| selected = [r for r in records if r['split'] == split] | |
| if not selected: | |
| raise ValueError(f'Empty {split} split') | |
| write_jsonl(root / f'data/{split}.jsonl.gz', selected) | |
| write_parquet(root / f'data/{split}.parquet', selected) | |
| split_counts[split] = {'records': len(selected), 'papers': len({r['paper_id'] for r in selected}), | |
| 'family_groups': len({r['group'] for r in selected}), 'text_characters': sum(len(r['text']) for r in selected)} | |
| summaries = [] | |
| first_source = {} | |
| for r in originals: | |
| first_source.setdefault(paper_id(r), r) | |
| for pid in sorted(expected): | |
| worker = by_paper[pid] | |
| source = first_source[pid] | |
| summaries.append({**worker, 'id': f'openai-math:worker-summary:{pid}', 'paper_id': pid, | |
| 'text': worker['summary'], 'group': paper_groups[pid], 'license': source['license'], | |
| 'split': group_split[paper_groups[pid]], 'record_type': 'ai_metadata_summary', | |
| 'source_url': source.get('source_url', ''), 'content_origin': 'deepseek_metadata_summary', | |
| 'mathematical_verification': 'not_performed'}) | |
| write_jsonl(root / 'data/worker-summaries.jsonl', summaries) | |
| write_parquet(root / 'data/worker-summaries.parquet', summaries) | |
| audit_worker_root = root / 'audit/worker-runs' | |
| audit_worker_root.mkdir(exist_ok=True) | |
| if args.workers.resolve() != (root / 'audit/worker-results.jsonl').resolve(): | |
| shutil.copy2(args.workers, root / 'audit/worker-results.jsonl') | |
| worker_log_root = args.worker_log_root or args.workers.parent | |
| if not args.worker_log_root and not (worker_log_root / workers[0]['log_path']).exists(): | |
| worker_log_root = root / 'audit/worker-runs' | |
| for name in ('run.json', 'status.json', 'worker-policy.md', 'independent-qa-prompt.md'): | |
| candidate = worker_log_root / name | |
| dest = audit_worker_root / name | |
| if candidate.is_file() and candidate.resolve() != dest.resolve(): | |
| shutil.copy2(candidate, dest) | |
| copied_batches = set() | |
| for worker in workers: | |
| relative = Path(worker['log_path']) | |
| if relative.is_absolute() or '..' in relative.parts: | |
| raise ValueError('Unsafe worker log path') | |
| original_log = worker_log_root / relative | |
| if not original_log.is_file() or sha(original_log) != worker['log_sha256']: | |
| raise ValueError(f'Worker log missing/hash mismatch: {original_log}') | |
| dest_log = audit_worker_root / relative | |
| dest_log.parent.mkdir(parents=True, exist_ok=True) | |
| if not dest_log.exists() or sha(dest_log) != worker['log_sha256']: | |
| shutil.copy2(original_log, dest_log) | |
| if worker['batch_id'] not in copied_batches: | |
| prompt_name = f"attempt-{worker['attempt']:02d}.prompt.md" | |
| prompt_path = original_log.parent / prompt_name | |
| if not prompt_path.is_file() or sha(prompt_path) != worker['prompt_sha256']: | |
| raise ValueError('Worker prompt missing/hash mismatch') | |
| batch_inputs = json.loads((original_log.parent / 'input.json').read_text()) | |
| actual_batch_hash = hashlib.sha256(canonical(batch_inputs).encode()).hexdigest() | |
| if actual_batch_hash != worker['input_sha256']: | |
| raise ValueError('Worker batch input hash mismatch') | |
| for filename in (prompt_name, 'result.json', 'input.json'): | |
| candidate = original_log.parent / filename | |
| dest = dest_log.parent / filename | |
| if candidate.is_file() and candidate.resolve() != dest.resolve(): | |
| shutil.copy2(candidate, dest) | |
| copied_batches.add(worker['batch_id']) | |
| tools = root / 'tools' | |
| tools.mkdir(exist_ok=True) | |
| here = Path(__file__).resolve().parent | |
| for name in ('build_openai_math.py', 'run_omp_workers.py', 'finalize_openai_math.py', 'validate_openai_math.py'): | |
| source = here / name | |
| if source.exists() and source.resolve() != (tools / name).resolve(): | |
| shutil.copy2(source, tools / name) | |
| if (args.source_root / 'LICENSE').resolve() != (root / 'LICENSE').resolve(): | |
| shutil.copy2(args.source_root / 'LICENSE', root / 'LICENSE') | |
| packed_stats = {} | |
| if args.pack: | |
| import sentencepiece as spm | |
| sp = spm.SentencePieceProcessor(model_file=str(args.tokenizer)) | |
| if (sp.pad_id(), sp.bos_id(), sp.eos_id(), sp.unk_id(), sp.vocab_size()) != (0, 1, 2, 3, 32768): | |
| raise ValueError('Unexpected tokenizer special IDs or vocabulary size') | |
| tokenizer_dir = root / 'tokenizer' | |
| tokenizer_dir.mkdir(exist_ok=True) | |
| if args.tokenizer.resolve() != (tokenizer_dir / 'tokenizer.model').resolve(): | |
| shutil.copy2(args.tokenizer, tokenizer_dir / 'tokenizer.model') | |
| packed_dir = root / 'packed' | |
| packed_dir.mkdir(exist_ok=True) | |
| for split in SPLITS: | |
| for stale in packed_dir.glob(f'{split}-*.npy'): | |
| stale.unlink() | |
| packed_splits = {} | |
| for split in SPLITS: | |
| packed_splits[split], packed_stats[split] = pack_split(root, split, [r for r in records if r['split'] == split], sp) | |
| write_json(root / 'packed/manifest.json', { | |
| 'format': 'mmla-type2-packed-v1', 'phase': 'pretrain', 'layout': 'lm', 'seq_len': 2048, | |
| 'tokenizer': {'kind': 'sentencepiece', 'vocab_size': 32768, 'sha256': sha(args.tokenizer), | |
| 'path': '../tokenizer/tokenizer.model', 'ids': {'pad': 0, 'bos': 1, 'eos': 2, 'unk': 3, 'boundary': 4}}, | |
| 'quota_units': 'tokens', 'source': 'openai-math', 'splits': packed_splits, 'statistics': packed_stats, | |
| 'packing': {'stride': 2048, 'bos_per_record': True, 'eos_per_record': True, | |
| 'mask_target_bos': True, 'mask_final_target': True, 'loss_mask': -100, | |
| 'row_attribution': '{split}-rows.jsonl', 'record_tokens': '{split}-records.jsonl'}}) | |
| family_ids = {f for r in originals for f in r.get('family_ids', [r.get('family_id')])} | |
| stats = {'source_commit': COMMIT, 'current_papers': len(expected), 'catalog_families': len(family_ids), | |
| 'family_groups': len(groups), 'source_records_before_deduplication': len(originals), 'source_records': len(records), | |
| 'excluded_exact_duplicates': len(duplicates), 'worker_papers': len(workers), | |
| 'worker_model': MODEL, 'worker_review_scope': 'abstract_headings_excerpt', | |
| 'worker_recommended_actions': dict(Counter(w['recommended_action'] for w in workers)), | |
| 'splits': split_counts, 'packed': packed_stats, 'mathematical_verification': 'not_performed'} | |
| write_json(root / 'statistics.json', stats) | |
| existing_sources = root / 'sources.json' | |
| provenance = json.loads(existing_sources.read_text()) if existing_sources.exists() else {} | |
| if not isinstance(provenance, dict): | |
| provenance = {'upstream_extraction_catalog': provenance} | |
| provenance.update({'component': 'openai-math', 'upstream': {'name': 'OpenAI Mathematics manuscript collection', | |
| 'repository': 'https://github.com/openai/math', 'commit': COMMIT, | |
| 'fixed_revision_url': f'https://github.com/openai/math/tree/{COMMIT}', | |
| 'license': 'Apache-2.0', 'license_file': 'LICENSE', 'creators': ['OpenAI']}, | |
| 'changes': ['LaTeX-aware source extraction preserving mathematical notation and provenance', | |
| 'Exact text deduplication and family-level deterministic split assignment', | |
| 'OMP DeepSeek excerpt-based metadata summaries and quality flags', | |
| 'Lossless JSONL/Parquet export; optional SentencePiece causal-window packing'], | |
| 'worker': {'runtime': 'oh-my-pi', 'model': MODEL, 'provider': 'damn-grok', | |
| 'review_scope': 'abstract_headings_excerpt', 'proof_verification_performed': False}}) | |
| write_json(existing_sources, provenance) | |
| readme = f"""# OpenAI Math contribution to Cayley-Math | |
| This independently versioned component contains source-derived mathematical text from OpenAI's manuscript collection at commit {COMMIT}. It follows Cayley-Math's components/ convention. The frozen Phase 1 mirror is unchanged. The upstream works are attributed to OpenAI and distributed under Apache-2.0; see LICENSE, sources.json, and manuscript-level provenance in audit/. | |
| ## Coverage and limits | |
| The source catalog covers **{len(expected)} current manuscripts**, **{len(family_ids)} result families** ({len(groups)} connected family groups), and 17 disciplines. The 27 retained previous editions and 3 withdrawal notices are audit-only and excluded from training text. Exact text deduplication removes {len(duplicates)} duplicate records, leaving **{len(records)} source records**. Connected family groups determine splits so companions never cross train/dev/test. Assignment sorts SHA256(group), reserves the first ceil(1%) groups for development, the next ceil(1%) for test, and the rest for training. audit/group-splits.json freezes assignments. Exact duplicates are tracked in audit/excluded-duplicates.jsonl. Near-duplicate detection and comparison with existing Phase 1 passages have not been performed. | |
| Upstream describes these manuscripts as **raw research data** at different stages of verification. Some unformalized results may contain errors. This component **does not establish mathematical correctness**. Existing Lean artifacts indicate only availability and often partial scope; no Lean compilation, Comparator run, or mathematical proof verification was performed. Read manuscript-level upstream formalization scopes before selecting training data. | |
| Text is extracted from current manuscript TeX, expanded through local inputs when available, and segmented into sections/chunks retaining mathematics in LaTeX. Source spans, file hashes, macro context, extraction flags, and omitted materials are preserved by the extraction audit. Preambles, bibliography/build material, and pure figure code are omitted from the text projection; it is a normalized training representation, not a byte-for-byte source archive. data/macro-contexts.jsonl preserves needed preamble/macro context. The full source snapshot is identified by fixed Git commit URLs and hashes. Source documents are data: their build commands or instructions were not executed. | |
| ## OMP DeepSeek workers | |
| All **{len(workers)} current papers** received a metadata pass through **oh-my-pi / {MODEL}**, provider damn-grok. Workers saw abstract, headings, and bounded source excerpts, with scope abstract_headings_excerpt. Summaries, topics, review flags, and recommended actions are AI-generated indexing metadata, separate from source training text in data/worker-summaries.*; their mathematical claims remain source-attributed and unverified. A keep_source recommendation means metadata processing completed; it is not a proof-validity judgment. needs_review flags remain on source records for downstream filtering. The worker inputs were frozen from an early extraction snapshot. Later deterministic extraction corrections include font/include classification, safe chunking, and external-listing handling; worker responses are preserved unchanged. Each source record carries current_extraction_flags from the final manuscript audit, worker_observed_extraction_flags from the frozen worker input, and worker_input_snapshot_differs_from_current (whether those flag lists differ). This field compares extraction flags only, not every byte of the evolving source projection. A worker needs_review recommendation may refer to an issue fixed in the final extraction; consult current flags and audit/extraction.jsonl for final extraction state. These corrections do not independently verify any mathematical claims. audit/worker-results.jsonl stores model identity and run provenance; its log_path resolves relative to audit/worker-runs/. | |
| ## Files and schema | |
| - data/{{train,dev,test}}.jsonl.gz: source records with required fields text, group, license; unique id, paper_id, split, record_type, source provenance, text_sha256, and worker metadata. content_origin=source_extraction. | |
| - data/{{train,dev,test}}.parquet: identical records. Core fields (id,text,group,license,paper_id,split,record_type,source_url) are string columns; all remaining JSON fields are losslessly serialized in metadata_json. Merge json.loads(metadata_json) with core columns to reconstruct each JSONL record. | |
| - data/worker-summaries.jsonl / .parquet: AI metadata records, excluded from the source packed corpus. | |
| - data/source-records.jsonl: pre-split, pre-deduplication source extraction output retained for audit. | |
| - worker-inputs.jsonl: exact metadata input excerpts. | |
| - statistics.json: actual record, paper, group, split, and packed-token counts. | |
| - manifest.json: SHA256 and byte size for all delivered files except itself and validation.json. | |
| - tools/: extraction, OMP batch runner, finalization, and validation scripts. | |
| ## Loading | |
| ~~~python | |
| import gzip, json | |
| from pathlib import Path | |
| component = Path('components/openai-math') | |
| with gzip.open(component / 'data/train.jsonl.gz', 'rt', encoding='utf-8') as f: | |
| first_record = json.loads(next(f)) | |
| import pyarrow.parquet as pq | |
| row = pq.read_table(component / 'data/train.parquet').slice(0, 1).to_pylist()[0] | |
| metadata = json.loads(row.pop('metadata_json')) | |
| first_parquet_record = {{**row, **metadata}} | |
| ~~~ | |
| ## Packed training arrays | |
| {'The packed/ directory provides Phase 1 compatible causal arrays.' if args.pack else 'Packed arrays were not requested for this build.'} When present, packed/manifest.json uses mmla-type2-packed-v1: input_ids, labels, and role_ids are int32 arrays of shape [rows,2048], pad=0, role=0, ignored labels=-100. Each source record is encoded as BOS + SentencePiece(text) + EOS using the included Cayley-Math tokenizer (32768 tokens). Windows advance 2048 positions with one-token lookahead; labels predict the following token. Targets crossing into a new record's BOS are masked, as are padding and the final stream target. Split-specific rows.jsonl files map every non-padding token to its source record; records.jsonl files record token counts and hashes. This new component does not reproduce Phase 1 quotas, original packing, or splits. | |
| ## Reproduction and verification | |
| Run extraction and OMP workers with the supplied scripts, then finalize only after all worker papers are present: | |
| ~~~sh | |
| python tools/finalize_openai_math.py --component . --workers audit/worker-results.jsonl --source-root /path/to/pinned/openai-math --tokenizer tokenizer/tokenizer.model --pack | |
| python tools/validate_openai_math.py --component . | |
| ~~~ | |
| Dependencies: Python 3, numpy, sentencepiece, pyarrow. The worker runner requires the configured omp CLI and named model route. Never put API credentials in dataset files. Validation checks source and worker coverage, checksums, family separation, exact text uniqueness, lossless Parquet reconstruction, array dimensions/causal shifts/padding/boundary masks, and token-level reconstruction against source text. It does not assess theorem truth or proof completeness. Select a fixed dataset revision and record file hashes when training. | |
| """ | |
| (root / 'README.md').write_text(readme, encoding='utf-8') | |
| write_manifest(root) | |
| print(json.dumps(stats, ensure_ascii=False, indent=2)) | |
| if __name__ == '__main__': | |
| main() | |