Datasets:
Tasks:
Text Generation
Formats:
parquet
Languages:
code
Size:
10B - 100B
Tags:
Synthetic
esoteric-programming-language
program-synthesis
kolmogorov-complexity
algorithmic-data
License:
| """The brainphoque machine: run a program and get its output. | |
| This file is the specification of the machine used for the brainphoque-minimal-14 dataset. | |
| `run_reference` is a direct, readable implementation; `run` uses the C version in bfrun.c | |
| when it has been built (cc -O2 -shared -fPIC -o libbfrun.so bfrun.c) and falls back to the | |
| reference otherwise. Both return identical results. | |
| Machine: a circular tape of 256 byte cells (all 0 at the start) and one head. Every symbol, | |
| macros included, costs one step. A run completes if it halts (runs off the end of the program) | |
| or prints its 4,095th byte within 65,536 steps; otherwise it has no output. The output is the | |
| first 4,095 printed bytes; outputs are compared after removing trailing zero bytes. | |
| """ | |
| import ctypes, os | |
| SYMBOLS = "<>+-[].ZRLNCGHWVX" | |
| TAPE, T, BUDGET = 256, 4095, 65536 | |
| HALT, FULL, CUT = "halts", "prints 4095 bytes", "cut" | |
| def run_reference(program): | |
| """Return (status, steps, output) for a program string; output has trailing zeros removed.""" | |
| match, stack = {}, [] | |
| for i, c in enumerate(program): # unmatched brackets are no-ops | |
| if c == '[': stack.append(i) | |
| elif c == ']' and stack: j = stack.pop(); match[i] = j; match[j] = i | |
| tape, out = bytearray(TAPE), bytearray() | |
| pc = p = steps = 0 | |
| def done(status): | |
| o = bytes(out) | |
| return status, steps, o.rstrip(b'\0') | |
| while pc < len(program): | |
| if steps >= BUDGET: return CUT, steps, b'' | |
| steps += 1 | |
| c = program[pc] | |
| if c == '+': tape[p] = (tape[p] + 1) & 255 | |
| elif c == '-': tape[p] = (tape[p] - 1) & 255 | |
| elif c == '>': p = (p + 1) % TAPE | |
| elif c == '<': p = (p - 1) % TAPE | |
| elif c == '[': | |
| if pc in match and tape[p] == 0: pc = match[pc] | |
| elif c == ']': | |
| if pc in match and tape[p] != 0: pc = match[pc] | |
| elif c == '.': | |
| out.append(tape[p]) | |
| if len(out) == T: return done(FULL) | |
| elif c == 'Z': tape[p] = 0 # [-] | |
| elif c == 'X': tape[p] = 16 | |
| elif c in 'RLNC': | |
| x = tape[p]; tape[p] = 0 | |
| if c == 'R': tape[(p + 1) % TAPE] = (tape[(p + 1) % TAPE] + x) & 255 # [->+<] | |
| elif c == 'L': tape[(p + 1) % TAPE] = (tape[(p + 1) % TAPE] + 3 * x) & 255 # [->+++<] | |
| elif c == 'N': tape[(p - 1) % TAPE] = (tape[(p - 1) % TAPE] - x) & 255 # [-<->] | |
| else: # [->+>+<<] | |
| tape[(p + 1) % TAPE] = (tape[(p + 1) % TAPE] + x) & 255 | |
| tape[(p + 2) % TAPE] = (tape[(p + 2) % TAPE] + x) & 255 | |
| elif c in 'GH': # [>] / [<]: move to the nearest zero cell | |
| d = 1 if c == 'G' else -1 | |
| for _ in range(TAPE): | |
| if tape[p] == 0: break | |
| p = (p + d) % TAPE | |
| if tape[p] != 0: return CUT, steps, b'' # no zero cell: never finishes | |
| elif c == 'W': # if nonzero: clear, add 1 to the right | |
| if tape[p]: tape[p] = 0; tape[(p + 1) % TAPE] = (tape[(p + 1) % TAPE] + 1) & 255 | |
| elif c == 'V': # [.>]: print and move right until a zero | |
| while tape[p]: | |
| out.append(tape[p]); p = (p + 1) % TAPE | |
| if len(out) == T: return done(FULL) | |
| else: | |
| raise ValueError(f"bad symbol {c!r}") | |
| pc += 1 | |
| return done(HALT) | |
| _lib = None | |
| def _load(): | |
| global _lib | |
| if _lib is None: | |
| path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'libbfrun.so') | |
| if os.path.exists(path): | |
| _lib = ctypes.CDLL(path) | |
| _lib.bf_run.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)] | |
| _lib.bf_run.restype = ctypes.c_int | |
| else: | |
| _lib = False | |
| return _lib | |
| def run(program): | |
| """Same as run_reference, using the C implementation when libbfrun.so is present.""" | |
| lib = _load() | |
| if not lib: return run_reference(program) | |
| buf = ctypes.create_string_buffer(T); n = ctypes.c_int(); s = ctypes.c_int() | |
| r = lib.bf_run(program.encode(), buf, ctypes.byref(n), ctypes.byref(s)) | |
| if r < 0: raise ValueError(f"bad program {program!r}") | |
| return (CUT, HALT, FULL)[r], s.value, buf.raw[:n.value].rstrip(b'\0') if r else b'' | |
| def padded(output): | |
| """The full 4,095-byte output (zero-padded), as used for training.""" | |
| return output + bytes(T - len(output)) | |