Datasets:
Tasks:
Text Generation
Formats:
parquet
Languages:
code
Size:
10B - 100B
Tags:
Synthetic
esoteric-programming-language
program-synthesis
kolmogorov-complexity
algorithmic-data
License:
| """Check an exported (or downloaded) brainphoque-minimal-14 dataset. | |
| Usage: python3 validate.py DATASET_DIR [--rows-per-file 2000] [--expected counts.tsv] | |
| For every Parquet file under DATASET_DIR/data: checks that all rows have the file's length, that | |
| programs are distinct and sorted in enumeration order, and re-runs a random sample of rows with bf.py, | |
| comparing halting, steps and output length. Prints rows per length and per class; with --expected | |
| (a TSV of length, rows) the totals must match. Exits non-zero on any failure. | |
| """ | |
| import argparse, glob, os, re, sys | |
| import numpy as np, pyarrow.parquet as pq | |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) | |
| import bf | |
| RANK = np.zeros(256, np.uint8) # symbol -> rank in enumeration order | |
| for i, c in enumerate(bf.SYMBOLS): RANK[ord(c)] = i | |
| def main(): | |
| ap = argparse.ArgumentParser(); ap.add_argument('root') | |
| ap.add_argument('--rows-per-file', type=int, default=2000); ap.add_argument('--expected') | |
| a = ap.parse_args(); rng = np.random.default_rng(0) | |
| files = sorted(glob.glob(os.path.join(a.root, 'data', 'length_*', '*.parquet'))) | |
| rows, classes, failures = {}, {}, 0 | |
| for path in files: | |
| L = int(re.search(r'length_(\d+)', path).group(1)) | |
| t = pq.read_table(path, columns=['program', 'length', 'halts', 'steps', 'output_length', 'output_class']) | |
| progs = t.column('program').to_pylist() | |
| ok = all(len(p) == L for p in progs) and set(t.column('length').to_pylist()) == {L} | |
| if ok and len(progs) > 1: # sorted and distinct | |
| r = RANK[np.frombuffer(''.join(progs).encode(), np.uint8).reshape(-1, L)] | |
| diff = r[1:] != r[:-1]; first = diff.argmax(1); rows_ = np.arange(len(first)) | |
| ok &= bool(diff.any(1).all() and (r[1:][rows_, first] > r[:-1][rows_, first]).all()) | |
| if not ok: failures += 1; print(f"{path}: wrong length, order or duplicates") | |
| halts, steps, olen = (t.column(c).to_numpy() for c in ('halts', 'steps', 'output_length')) | |
| for i in rng.choice(len(progs), min(len(progs), a.rows_per_file), replace=False): | |
| st, s, out = bf.run(progs[i]) | |
| if (st, s, len(out)) != (bf.HALT if halts[i] else bf.FULL, steps[i], olen[i]): | |
| failures += 1; print(f"{path}: {progs[i]} replays as {(st, s, len(out))}") | |
| rows[L] = rows.get(L, 0) + t.num_rows | |
| for c, n in zip(*np.unique(t.column('output_class').to_pandas().astype(str), return_counts=True)): | |
| classes[(L, c)] = classes.get((L, c), 0) + int(n) | |
| for L in sorted(rows): print(f"length {L}: {rows[L]:,} rows") | |
| print(f"total: {sum(rows.values()):,} rows in {len(files)} files") | |
| for c in sorted({c for _, c in classes}): | |
| print(f" {c}: {sum(n for (L, cc), n in classes.items() if cc == c):,}") | |
| if a.expected: | |
| for line in open(a.expected): | |
| L, n = map(int, line.split()) | |
| if rows.get(L, 0) != n: failures += 1; print(f"length {L}: {rows.get(L, 0)} rows, expected {n}") | |
| print("OK" if not failures else f"{failures} FAILURES"); sys.exit(1 if failures else 0) | |
| if __name__ == '__main__': | |
| main() | |