| """Complete finite-world witness synthesis for compositional numeric programs. |
| |
| Worlds contain four labelled integer cells in a declared inclusive domain. |
| The renderer redacts complete cells before drawing. The finite-domain |
| restriction is explicit: this is not a certificate for arbitrary real worlds. |
| """ |
|
|
| import base64 |
| import copy |
| import io |
| import itertools |
| from fractions import Fraction |
|
|
| OPS = {"add", "sub", "mul", "div", "min", "max", "gt", "eq"} |
| LABELS = ("A", "B", "C", "D") |
|
|
|
|
| def evaluate(program, world): |
| """Recursive exact-rational executor used by the synthesizer.""" |
| op = program[0] |
| if op == "cell": |
| return Fraction(world[program[1]]) |
| if op == "const": |
| return Fraction(program[1]) |
| a, b = (evaluate(p, world) for p in program[1:]) |
| if op == "add": |
| return a + b |
| if op == "sub": |
| return a - b |
| if op == "mul": |
| return a * b |
| if op == "div": |
| return a / b |
| if op == "min": |
| return min(a, b) |
| if op == "max": |
| return max(a, b) |
| if op == "gt": |
| return int(a > b) |
| if op == "eq": |
| return int(a == b) |
| raise ValueError("unsupported operator") |
|
|
|
|
| def reference_evaluate(program, world): |
| """Separate postfix stack executor; it does not call evaluate.""" |
| todo, code = [(program, False)], [] |
| while todo: |
| node, visited = todo.pop() |
| if node[0] in ("cell", "const") or visited: |
| code.append(node[:2] if node[0] in ("cell", "const") else [node[0]]) |
| else: |
| todo.extend([(node, True), (node[2], False), (node[1], False)]) |
| stack = [] |
| for instruction in code: |
| op = instruction[0] |
| if op == "cell": |
| stack.append(Fraction(world[instruction[1]])) |
| elif op == "const": |
| stack.append(Fraction(instruction[1])) |
| else: |
| right, left = stack.pop(), stack.pop() |
| operations = { |
| "add": lambda: left + right, "sub": lambda: left - right, |
| "mul": lambda: left * right, "div": lambda: left / right, |
| "min": lambda: left if left <= right else right, |
| "max": lambda: right if left <= right else left, |
| "gt": lambda: Fraction(int(left > right)), |
| "eq": lambda: Fraction(int(left == right)), |
| } |
| stack.append(operations[op]()) |
| if len(stack) != 1: |
| raise ValueError("invalid postfix program") |
| return stack[0] |
|
|
|
|
| def validate_program(program, depth=0): |
| if depth > 12 or not isinstance(program, list) or not program: |
| raise ValueError("invalid program") |
| op = program[0] |
| if op in ("cell", "const"): |
| if len(program) != 2: |
| raise ValueError("invalid leaf") |
| if op == "cell" and (type(program[1]) is not int or program[1] not in range(4)): |
| raise ValueError("unknown cell") |
| if op == "const" and (type(program[1]) is not int or abs(program[1]) > 100): |
| raise ValueError("invalid constant") |
| else: |
| if op not in OPS or len(program) != 3: |
| raise ValueError("unknown operation") |
| for child in program[1:]: |
| validate_program(child, depth + 1) |
| if op == "div" and not (program[2][0] == "const" and program[2][1] != 0): |
| raise ValueError("division requires a nonzero constant denominator") |
|
|
|
|
| def question(program): |
| op = program[0] |
| if op == "cell": |
| return LABELS[program[1]] |
| if op == "const": |
| return str(program[1]) |
| symbols = {"add": "+", "sub": "-", "mul": "*", "div": "/", "gt": ">", "eq": "="} |
| a, b = map(question, program[1:]) |
| return f"{op}({a}, {b})" if op in ("min", "max") else f"({a} {symbols[op]} {b})" |
|
|
|
|
| def observation(world, hidden): |
| return [None if i in hidden else value for i, value in enumerate(world)] |
|
|
|
|
| def render(observed, domain): |
| """Byte-exact RGB observation, with a fixed public axis and value labels.""" |
| from PIL import Image, ImageDraw |
|
|
| image = Image.new("RGB", (400, 260), "white") |
| draw = ImageDraw.Draw(image) |
| draw.text((12, 8), f"Integer values: {domain[0]} to {domain[1]}", fill="black") |
| for i, value in enumerate(observed): |
| left = 18 + 95 * i |
| draw.rectangle((left, 40, left + 70, 230), outline="black") |
| draw.text((left + 29, 238), LABELS[i], fill="black") |
| if value is None: |
| draw.rectangle((left + 1, 41, left + 69, 229), fill=(210, 210, 210)) |
| draw.text((left + 9, 125), "HIDDEN", fill="black") |
| else: |
| y = 225 - round(155 * (value - domain[0]) / (domain[1] - domain[0])) |
| draw.rectangle((left + 12, y, left + 58, 225), fill=(45, 102, 164)) |
| draw.text((left + 24, 46), str(value), fill="black") |
| return image |
|
|
|
|
| def completions(observed, domain): |
| hidden = [i for i, value in enumerate(observed) if value is None] |
| for values in itertools.product(range(domain[0], domain[1] + 1), repeat=len(hidden)): |
| world = list(observed) |
| for i, value in zip(hidden, values, strict=True): |
| world[i] = value |
| yield world |
|
|
|
|
| def validate_observation(observed, domain): |
| if (not isinstance(domain, list) or len(domain) != 2 |
| or any(type(x) is not int for x in domain) or not 0 < domain[1] - domain[0] <= 20): |
| raise ValueError("unsupported finite domain") |
| if not isinstance(observed, list) or len(observed) != 4: |
| raise ValueError("expected four cells") |
| if sum(x is None for x in observed) > 3: |
| raise ValueError("at most three hidden cells") |
| if any(x is not None and (type(x) is not int or not domain[0] <= x <= domain[1]) |
| for x in observed): |
| raise ValueError("observed value outside domain") |
|
|
|
|
| def synthesize(program, observed, domain): |
| """Exhaustively find a separating pair, or report a constant finite answer.""" |
| validate_program(program) |
| validate_observation(observed, domain) |
| first, first_answer, inspected = None, None, 0 |
| for world in completions(observed, domain): |
| answer = evaluate(program, world) |
| inspected += 1 |
| if first is None: |
| first, first_answer = world, answer |
| elif answer != first_answer: |
| buf = io.BytesIO() |
| render(observed, domain).save(buf, format="PNG") |
| return { |
| "status": "ambiguous", "worlds_inspected": inspected, |
| "proof": { |
| "schema": "finite_compositional_witness_v1", |
| "domain": domain, "program": copy.deepcopy(program), |
| "question": question(program), "observation": observed, |
| "witnesses": [first, world], |
| "observed_png": base64.b64encode(buf.getvalue()).decode("ascii"), |
| }, |
| } |
| return {"status": "constant", "worlds_inspected": inspected, "answer": str(first_answer)} |
|
|
|
|
| def verify(proof): |
| """Check complete-world membership, both executors, question and pixels.""" |
| from PIL import Image |
|
|
| try: |
| if proof["schema"] != "finite_compositional_witness_v1": |
| raise ValueError("schema") |
| program, observed, domain = proof["program"], proof["observation"], proof["domain"] |
| validate_program(program) |
| validate_observation(observed, domain) |
| if proof["question"] != question(program): |
| raise ValueError("question/program mismatch") |
| hidden = [i for i, v in enumerate(observed) if v is None] |
| png = base64.b64decode(proof["observed_png"], validate=True) |
| image = Image.open(io.BytesIO(png)).convert("RGB") |
| expected = render(observed, domain) |
| if image.size != expected.size or image.tobytes() != expected.tobytes(): |
| raise ValueError("observed pixels mismatch") |
| answers = [] |
| if len(proof["witnesses"]) != 2: |
| raise ValueError("two worlds required") |
| for world in proof["witnesses"]: |
| if (len(world) != 4 or any(type(v) is not int or not domain[0] <= v <= domain[1] |
| for v in world)): |
| raise ValueError("inadmissible complete world") |
| if observation(world, hidden) != observed: |
| raise ValueError("visible value mismatch") |
| rendered = render(observation(world, hidden), domain) |
| if rendered.tobytes() != image.tobytes(): |
| raise ValueError("witness pixels mismatch") |
| answer = reference_evaluate(program, world) |
| if answer != evaluate(program, world): |
| raise ValueError("executor disagreement") |
| answers.append(str(answer)) |
| if answers[0] == answers[1]: |
| raise ValueError("answers are identical") |
| return {"ok": True, "answers": answers} |
| except (ValueError, KeyError, TypeError, IndexError, ZeroDivisionError, OSError) as exc: |
| return {"ok": False, "error": str(exc)} |
|
|
