Datasets:
Download components/openai-math/tools/validate_openai_math.py from MMLA-ORG/Cayley-Math: direct link, hf CLI and curl.
- Browser
- Download file 21 kB
-
https://huggingface.co/datasets/MMLA-ORG/Cayley-Math/resolve/refs%2Fpr%2F3/components/openai-math/tools/validate_openai_math.py
- Command line
-
hf download hf://datasets/MMLA-ORG/Cayley-Math@refs/pr/3/components/openai-math/tools/validate_openai_math.py
-
curl -L -o validate_openai_math.py https://huggingface.co/datasets/MMLA-ORG/Cayley-Math/resolve/refs%2Fpr%2F3/components/openai-math/tools/validate_openai_math.py
21 kB
| #!/usr/bin/env python3 | |
| """Validate component transport, provenance, leakage controls and packed tokens.""" | |
| from __future__ import annotations | |
| import argparse | |
| from collections import Counter | |
| import gzip | |
| import hashlib | |
| import json | |
| from pathlib import Path | |
| import re | |
| CORE = ('id', 'text', 'group', 'license', 'paper_id', 'split', 'record_type', 'source_url') | |
| MODEL = 'deepseek-v4.1-flash' | |
| COMMIT = '4eaee87548250b2682affda7d05d947c05554bae' | |
| SPLITS = ('train', 'dev', 'test') | |
| def ensure(condition, message): | |
| if not condition: | |
| raise ValueError(message) | |
| 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: | |
| return [json.loads(line) for line in f if line.strip()] | |
| def read_json(path): | |
| return json.loads(Path(path).read_text(encoding='utf-8')) | |
| def safe_path(root, relative): | |
| ensure(not Path(relative).is_absolute(), 'Absolute manifest/provenance path') | |
| p = (root / relative).resolve() | |
| ensure(p.is_relative_to(root.resolve()), 'Path escapes component root') | |
| return p | |
| def check_parquet(path, expected): | |
| import pyarrow.parquet as pq | |
| table = pq.read_table(path) | |
| ensure(table.column_names == [*CORE, 'metadata_json'], f'Parquet columns: {path}') | |
| ensure(table.num_rows == len(expected), f'Parquet row count: {path}') | |
| for index, (row, original) in enumerate(zip(table.to_pylist(), expected)): | |
| metadata = json.loads(row.pop('metadata_json')) | |
| reconstructed = {**row, **metadata} | |
| ensure(reconstructed == original, f'Parquet mismatch {path}:{index}') | |
| def final_worker_message(log): | |
| final = None | |
| for line in log.read_text(encoding='utf-8', errors='replace').splitlines(): | |
| try: | |
| event = json.loads(line) | |
| except json.JSONDecodeError: | |
| continue | |
| if event.get('type') in {'message_end', 'turn_end'} and event.get('message', {}).get('role') == 'assistant': | |
| final = event['message'] | |
| ensure(final is not None, f'No final worker response: {log}') | |
| ensure(final.get('model') == MODEL and final.get('provider') == 'damn-grok', 'Worker log model/provider') | |
| ensure(final.get('stopReason') in {'stop', 'end_turn'}, 'Worker log did not finish normally') | |
| content = final.get('content', []) | |
| text = content if isinstance(content, str) else ''.join(x.get('text', '') for x in content if x.get('type') == 'text') | |
| text = text.strip() | |
| fence = chr(96) * 3 | |
| if text.startswith(fence) and text.endswith(fence): | |
| text = text[len(fence):-len(fence)].strip() | |
| if text.startswith('json'): | |
| text = text[4:].strip() | |
| result = json.loads(text) | |
| return result['papers'] | |
| def validate_packed(root, split_records): | |
| import numpy as np | |
| import sentencepiece as spm | |
| packed = root / 'packed' | |
| manifest = read_json(packed / 'manifest.json') | |
| ensure(manifest['format'] == 'mmla-type2-packed-v1', 'Packed format') | |
| ensure(manifest['seq_len'] == 2048, 'Packed sequence length') | |
| tokenizer = (packed / manifest['tokenizer']['path']).resolve() | |
| ensure(tokenizer.is_relative_to(root), 'Tokenizer path escapes component') | |
| ensure(sha(tokenizer) == manifest['tokenizer']['sha256'], 'Tokenizer hash') | |
| sp = spm.SentencePieceProcessor(model_file=str(tokenizer)) | |
| ensure((sp.pad_id(), sp.bos_id(), sp.eos_id(), sp.unk_id(), sp.vocab_size()) == (0, 1, 2, 3, 32768), 'Tokenizer IDs') | |
| result = {} | |
| for split in SPLITS: | |
| records = split_records[split] | |
| token_catalog = read_jsonl(packed / f'{split}-records.jsonl') | |
| rows = read_jsonl(packed / f'{split}-rows.jsonl') | |
| ensure([r['id'] for r in records] == [r['id'] for r in token_catalog], f'{split} packed source ordering') | |
| arrays, doc_offsets, stream_start = [], [], 0 | |
| for r, entry in zip(records, token_catalog): | |
| tokens = np.asarray([1] + sp.encode(r['text'], out_type=int) + [2], dtype='<i4') | |
| ensure(len(tokens) == entry['tokens'], f'{split} record token count') | |
| ensure(hashlib.sha256(tokens.tobytes()).hexdigest() == entry['token_sha256'], f'{split} record token hash') | |
| ensure(r['paper_id'] == entry['paper_id'], f'{split} record paper ID') | |
| doc_offsets.append((stream_start, stream_start + len(tokens), r['id'], r['paper_id'])) | |
| stream_start += len(tokens) | |
| arrays.append(tokens) | |
| stream = np.concatenate(arrays) | |
| del arrays | |
| cursor, doc_index, row_number, labels_count = 0, 0, 0, 0 | |
| for shard_index, shard in enumerate(manifest['splits'][split]): | |
| loaded = {} | |
| for name in ('input_ids', 'labels', 'role_ids'): | |
| field = shard['fields'][name] | |
| path = safe_path(packed, field['path']) | |
| ensure(path.stat().st_size == field['bytes'] and sha(path) == field['sha256'], f'Packed file hash/size: {path}') | |
| array = np.load(path, mmap_mode='r', allow_pickle=False) | |
| ensure(array.dtype == np.dtype('int32'), 'Packed dtype') | |
| ensure(list(array.shape) == field['shape'] == [shard['count'], 2048], 'Packed shape') | |
| loaded[name] = array | |
| ensure(np.all(loaded['role_ids'] == 0), 'Nonzero plain-text role') | |
| for shard_row in range(shard['count']): | |
| ensure(row_number < len(rows), 'Missing row attribution') | |
| attribution = rows[row_number] | |
| n = min(2048, len(stream) - cursor) | |
| ensure(n > 0, 'Unexpected all-padding row') | |
| expect_input = np.zeros(2048, dtype=np.int32) | |
| expect_input[:n] = stream[cursor:cursor+n] | |
| expect_labels = np.full(2048, -100, dtype=np.int32) | |
| available = min(n, len(stream) - cursor - 1) | |
| if available > 0: | |
| expect_labels[:available] = stream[cursor+1:cursor+1+available] | |
| expect_labels[expect_labels == 1] = -100 | |
| ensure(np.array_equal(loaded['input_ids'][shard_row], expect_input), f'{split} source token mismatch at row {row_number}') | |
| ensure(np.array_equal(loaded['labels'][shard_row], expect_labels), f'{split} label shift/mask mismatch at row {row_number}') | |
| ensure(attribution['row'] == row_number and attribution['shard'] == shard_index and attribution['shard_row'] == shard_row, 'Row location attribution') | |
| ensure(attribution['stream_start'] == cursor and attribution['length'] == n, 'Row stream attribution') | |
| while doc_index < len(doc_offsets) and doc_offsets[doc_index][1] <= cursor: | |
| doc_index += 1 | |
| spans = [] | |
| k = doc_index | |
| while k < len(doc_offsets) and doc_offsets[k][0] < cursor + n: | |
| start, end, rid, pid = doc_offsets[k] | |
| lo, hi = max(cursor, start), min(cursor+n, end) | |
| if lo < hi: | |
| spans.append({'record_id': rid, 'paper_id': pid, | |
| 'row_start': lo-cursor, 'row_end': hi-cursor, | |
| 'record_start': lo-start, 'record_end': hi-start}) | |
| k += 1 | |
| ensure(attribution['segments'] == spans, 'Token source attribution mismatch') | |
| labels_count += int(np.count_nonzero(expect_labels != -100)) | |
| cursor += n | |
| row_number += 1 | |
| ensure(cursor == len(stream), f'{split} token stream not fully consumed') | |
| ensure(row_number == len(rows), f'{split} extra row attribution') | |
| actual = {'rows': row_number, 'tokens': len(stream), 'loss_bearing_labels': labels_count} | |
| ensure(actual == manifest['statistics'][split], f'{split} packed statistics mismatch') | |
| result[split] = actual | |
| print(f'Validated packed {split}: {row_number} rows, {len(stream)} tokens', flush=True) | |
| return result | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument('--component', type=Path, default=Path('work/staging/openai-math')) | |
| parser.add_argument('--expected-papers', type=int, default=721) | |
| parser.add_argument('--source-root', type=Path, default=Path('/Users/zxy/math')) | |
| parser.add_argument('--skip-source-files', action='store_true', help='Validate transport without local upstream source checkout') | |
| args = parser.parse_args() | |
| root = args.component.resolve() | |
| checks = [] | |
| manifest = read_json(root / 'manifest.json') | |
| expected_files = {x['path'] for x in manifest['files']} | |
| actual_files = {p.relative_to(root).as_posix() for p in root.rglob('*') if p.is_file() and p.relative_to(root).as_posix() not in {'manifest.json', 'validation.json'}} | |
| ensure(expected_files == actual_files, f'File manifest coverage mismatch: missing={expected_files-actual_files}, extra={actual_files-expected_files}') | |
| for item in manifest['files']: | |
| path = safe_path(root, item['path']) | |
| ensure(path.stat().st_size == item['bytes'], f'Byte count: {path}') | |
| ensure(sha(path) == item['sha256'], f'File digest: {path}') | |
| checks.append('all_delivered_file_hashes_and_sizes') | |
| inputs = read_jsonl(root / 'worker-inputs.jsonl') | |
| input_by_id = {r['paper_id']: r for r in inputs} | |
| expected = set(input_by_id) | |
| ensure(len(expected) == len(inputs) == args.expected_papers, 'Current paper expected count') | |
| manuscripts = read_jsonl(root / 'audit/manuscripts.jsonl') | |
| status = Counter(x['status'] for x in manuscripts) | |
| ensure(status == {'current': args.expected_papers, 'previous': 27, 'withdrawn': 3}, f'Manuscript status coverage: {status}') | |
| ensure({x['paper_id'] for x in manuscripts if x['status'] == 'current'} == expected, 'Current inventory identity') | |
| checks.append('721_current_27_previous_3_withdrawn_inventory') | |
| workers = read_jsonl(root / 'audit/worker-results.jsonl') | |
| ensure(len(workers) == len({w['paper_id'] for w in workers}) == args.expected_papers, 'Worker unique coverage') | |
| ensure({w['paper_id'] for w in workers} == expected, 'Worker input coverage') | |
| log_results = {} | |
| batch_inputs_cache = {} | |
| for w in workers: | |
| ensure(w.get('model') == MODEL and w.get('provider') == 'damn-grok' and w.get('runner') == 'oh-my-pi', 'Worker identity') | |
| ensure(w['review_scope'] == 'abstract_headings_excerpt', 'Worker review scope') | |
| ensure(w['recommended_action'] in {'keep_source', 'needs_review'}, 'Worker recommendation') | |
| ensure({'not_independently_verified', 'excerpt_review_only'} <= set(w['quality_flags']), 'Worker caveats') | |
| ensure(80 <= len(w['summary'].split()) <= 150, 'Worker summary length') | |
| ensure(hashlib.sha256(canonical(input_by_id[w['paper_id']]).encode()).hexdigest() == w['source_input_sha256'], 'Worker individual input hash') | |
| log = safe_path(root / 'audit/worker-runs', w['log_path']) | |
| ensure(sha(log) == w['log_sha256'], 'Worker log digest') | |
| if str(log) not in log_results: | |
| raw_papers = final_worker_message(log) | |
| ensure(len(raw_papers) == len({p['paper_id'] for p in raw_papers}), 'Worker raw response duplicate IDs') | |
| log_results[str(log)] = {p['paper_id']: p for p in raw_papers} | |
| batch_inputs = read_json(log.parent / 'input.json') | |
| ensure([p['paper_id'] for p in raw_papers] == [p['paper_id'] for p in batch_inputs], 'Worker batch raw response ID order') | |
| ensure(all(p == input_by_id[p['paper_id']] for p in batch_inputs), 'Worker batch input differs from source inputs') | |
| ensure(hashlib.sha256(canonical(batch_inputs).encode()).hexdigest() == w['input_sha256'], 'Worker batch input digest') | |
| batch_inputs_cache[str(log)] = w['input_sha256'] | |
| ensure(batch_inputs_cache[str(log)] == w['input_sha256'], 'Worker batch inconsistent digest') | |
| prompt_path = log.parent / f"attempt-{w['attempt']:02d}.prompt.md" | |
| ensure(sha(prompt_path) == w['prompt_sha256'], 'Worker prompt digest') | |
| raw_result = log_results[str(log)][w['paper_id']] | |
| ensure(all(w[k] == raw_result[k] for k in ('paper_id', 'summary', 'topics', 'quality_flags', 'recommended_action', 'review_scope')), 'Worker log/result mismatch') | |
| checks.append('all_721_real_omp_deepseek_responses_and_input_hashes') | |
| source_records = read_jsonl(root / 'data/source-records.jsonl') | |
| source_by_id = {r['id']: r for r in source_records} | |
| ensure(len(source_by_id) == len(source_records), 'Source extraction duplicate IDs') | |
| ensure({r['paper_id'] for r in source_records} == expected, 'Full source paper coverage') | |
| macros = read_jsonl(root / 'data/macro-contexts.jsonl') | |
| macro_ids = {r.get('id') or r.get('macro_context_id') for r in macros} | |
| checked_source_files = {} | |
| for r in source_records: | |
| ensure(r['source_commit'] == COMMIT and COMMIT in r['source_url'], 'Source pinned commit') | |
| ensure(r['license'] == 'Apache-2.0', 'Source license') | |
| ensure(r['verification_status'] == 'unverified_source_claim' and r['lean_verified'] is False, 'Source verification status') | |
| ensure(r['macro_context_id'] in macro_ids, 'Source macro context dangling link') | |
| spans = r['source_spans'] | |
| ensure(spans, 'Source record has no source spans') | |
| if not args.skip_source_files: | |
| for span in spans: | |
| path = safe_path(args.source_root, span['path']) | |
| if str(path) not in checked_source_files: | |
| checked_source_files[str(path)] = sha(path) | |
| ensure(checked_source_files[str(path)] == span['sha256'], f'Source span hash: {path}') | |
| ensure(span['start_line'] > 0 and span['end_line'] >= span['start_line'], 'Source line span invalid') | |
| if not args.skip_source_files: | |
| for macro in macros: | |
| for context in macro['contexts']: | |
| path = safe_path(args.source_root, context['source_path']) | |
| if str(path) not in checked_source_files: | |
| checked_source_files[str(path)] = sha(path) | |
| ensure(checked_source_files[str(path)] == context['source_sha256'], 'Macro source file digest') | |
| ensure(context['start_line'] > 0 and context['end_line'] >= context['start_line'], 'Macro context source lines') | |
| for file in read_jsonl(root / 'audit/source-files.jsonl'): | |
| path = safe_path(args.source_root, file['path']) | |
| if str(path) not in checked_source_files: | |
| checked_source_files[str(path)] = sha(path) | |
| ensure(checked_source_files[str(path)] == file['sha256'], 'Source file inventory digest') | |
| ensure(path.stat().st_size == file['bytes'], 'Source file inventory size') | |
| checks.append('source_and_macro_provenance' + ('_local_files' if not args.skip_source_files else '_metadata_only')) | |
| group_splits = read_json(root / 'audit/group-splits.json') | |
| split_records, ids, hashes, paper_groups, seen_groups, family_splits = {}, set(), set(), {}, {}, {} | |
| workers_by_id = {r['paper_id']: r for r in workers} | |
| current_manuscripts = {r['paper_id']: r for r in manuscripts if r['status'] == 'current'} | |
| for split in SPLITS: | |
| rows = read_jsonl(root / f'data/{split}.jsonl.gz') | |
| ensure(rows, f'Empty split {split}') | |
| check_parquet(root / f'data/{split}.parquet', rows) | |
| for r in rows: | |
| ensure(r['split'] == split and group_splits[r['group']] == split, 'Family split assignment') | |
| ensure(r['id'] not in ids, 'Cross-split duplicate ID') | |
| ids.add(r['id']) | |
| digest = hashlib.sha256(r['text'].encode('utf-8')).hexdigest() | |
| ensure(r['text_sha256'] == digest and digest not in hashes, 'Exact text duplicate or digest mismatch') | |
| hashes.add(digest) | |
| original = source_by_id[r['id']] | |
| ensure(all(r[k] == v for k, v in original.items()), 'Source text/provenance changed during packaging') | |
| ensure(r['content_origin'] == 'source_extraction' and r['mathematical_verification'] == 'not_performed', 'Source/AI distinction') | |
| ensure(r['worker_model'] == MODEL, 'Source worker model') | |
| current_flags = current_manuscripts[r['paper_id']].get('extraction_flags', []) | |
| observed_flags = input_by_id[r['paper_id']].get('extraction_flags', []) | |
| ensure(r['current_extraction_flags'] == current_flags, 'Current extraction flags differ from final manuscript audit') | |
| ensure(r['worker_observed_extraction_flags'] == observed_flags, 'Worker-observed extraction flags differ from frozen input') | |
| ensure(r['worker_input_snapshot_differs_from_current'] is (current_flags != observed_flags), 'Worker snapshot flag comparison differs') | |
| ensure(isinstance(r.get('worker_snapshot_note'), str) and bool(r['worker_snapshot_note']), 'Missing worker snapshot scope note') | |
| ensure(all(r['worker_metadata'][k] == workers_by_id[r['paper_id']][k] for k in ('topics', 'quality_flags', 'recommended_action', 'review_scope')), 'Source worker metadata mismatch') | |
| ensure(r['paper_id'] in expected, 'Training includes excluded manuscript') | |
| if r['group'] in seen_groups: | |
| ensure(seen_groups[r['group']] == split, 'Family cross-split leakage') | |
| seen_groups[r['group']] = split | |
| for family in r['family_ids']: | |
| if family in family_splits: | |
| ensure(family_splits[family] == split, 'Catalog family crosses split groups') | |
| family_splits[family] = split | |
| if r['paper_id'] in paper_groups: | |
| ensure(paper_groups[r['paper_id']] == r['group'], 'Paper has multiple split groups') | |
| paper_groups[r['paper_id']] = r['group'] | |
| split_records[split] = rows | |
| ensure(set(paper_groups) == expected, 'All 721 papers present after deduplication') | |
| duplicates = read_jsonl(root / 'audit/excluded-duplicates.jsonl') | |
| ensure(ids | {d['excluded_id'] for d in duplicates} == set(source_by_id), 'Dedup audit coverage') | |
| for d in duplicates: | |
| ensure(d['kept_id'] in ids, 'Dedup kept ID absent') | |
| ensure(source_by_id[d['excluded_id']]['text'] == source_by_id[d['kept_id']]['text'], 'Dedup text differs') | |
| checks.append('lossless_jsonl_parquet_and_exact_dedup_audit') | |
| checks.append('connected_family_group_and_paper_split_separation') | |
| checks.append('frozen_worker_observed_flags_and_final_extraction_flags_distinguished') | |
| summaries = read_jsonl(root / 'data/worker-summaries.jsonl') | |
| check_parquet(root / 'data/worker-summaries.parquet', summaries) | |
| ensure({r['paper_id'] for r in summaries} == expected and len(summaries) == args.expected_papers, 'Summary coverage') | |
| for r in summaries: | |
| ensure(r['text'] == workers_by_id[r['paper_id']]['summary'], 'Summary differs from worker') | |
| ensure(r['record_type'] == 'ai_metadata_summary' and r['content_origin'] == 'deepseek_metadata_summary', 'Summary labeling') | |
| ensure(r['split'] == group_splits[r['group']], 'Summary split') | |
| checks.append('separate_ai_metadata_summary_transport') | |
| packed = validate_packed(root, split_records) if (root / 'packed/manifest.json').exists() else {} | |
| if packed: | |
| checks.append('all_packed_tokens_reencoded_source_shift_padding_masks_and_attribution') | |
| stats = read_json(root / 'statistics.json') | |
| ensure(stats['current_papers'] == stats['worker_papers'] == args.expected_papers, 'Statistics coverage') | |
| ensure(stats['source_records'] == sum(len(x) for x in split_records.values()), 'Statistics record count') | |
| ensure(stats['packed'] == packed, 'Statistics packed counts') | |
| report = {'status': 'passed', 'source_commit': COMMIT, 'current_papers': args.expected_papers, | |
| 'source_records': stats['source_records'], 'source_files_hashed': len(checked_source_files), | |
| 'worker_model': MODEL, 'worker_batches': len(log_results), 'checks': checks, 'packed': packed, | |
| 'mathematical_verification': 'not_performed', | |
| 'limitations': ['Worker metadata review uses abstracts, headings and bounded excerpts.', | |
| 'No theorem correctness assessment or Lean/Comparator compilation.', | |
| 'No near-duplicate or Phase 1 overlap assessment.']} | |
| (root / 'validation.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') | |
| print(json.dumps(report, ensure_ascii=False, indent=2)) | |
| if __name__ == '__main__': | |
| main() | |