| """Verify two complete witnesses in the fixed-axis PlotQA lookup world class. |
| |
| The question/program compilation, source truth, source generator distribution, |
| and correctness of the drawing primitives remain assumptions. No model, network, |
| credential, file identity, or persisted digest participates in acceptance. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import base64 |
| import copy |
| from fractions import Fraction |
|
|
| from .plot_observation import pixels, render_direct, visible_projection |
|
|
|
|
| def build_bounded_plot_proof( |
| *, |
| group_id, |
| question, |
| program, |
| full_world, |
| changed_world, |
| observed_world, |
| observed_png, |
| renderer, |
| ): |
| """Construct a proof from a group's existing complete and missing views. |
| |
| This supplements the historical release without changing its images or gold. |
| Invalid source pairs fail instead of falling back to arbitrary completions. |
| """ |
| row = { |
| "schema_version": 1, |
| "world_class": "plotqa_fixed_axis_lookup_v1", |
| "group_id": group_id, |
| "question": question, |
| "program": copy.deepcopy(program), |
| "complete_witness_a": copy.deepcopy(full_world), |
| "complete_witness_b": copy.deepcopy(changed_world), |
| "observed_world": copy.deepcopy(observed_world), |
| "observed_png_base64": base64.b64encode(observed_png).decode("ascii"), |
| "renderer": {key: renderer[key] for key in ("renderer_id", "width", "height")}, |
| } |
| result = verify_bounded_plot(row) |
| if not result["ok"]: |
| raise ValueError("Cannot construct bounded proof: " + "; ".join(result["errors"])) |
| return row |
|
|
|
|
| def verify_bounded_plot(row): |
| import numpy as np |
|
|
| from ..executors.plot import PlotExecutor |
| from ..executors.reference_plot import ReferencePlotExecutor |
| from .build import program_from_dict |
|
|
| if not isinstance(row, dict): |
| return {"group_id": None, "ok": False, "answers": [], "errors": ["record_is_not_object"]} |
| errors, answers = [], [] |
| if ( |
| row.get("schema_version", 1) != 1 |
| or row.get("world_class", "plotqa_fixed_axis_lookup_v1") != "plotqa_fixed_axis_lookup_v1" |
| ): |
| return { |
| "group_id": row.get("group_id"), |
| "ok": False, |
| "answers": [], |
| "errors": ["unsupported_proof_contract"], |
| } |
| try: |
| if not isinstance(row.get("question"), str) or not row["question"].strip(): |
| raise ValueError("question_missing") |
| if not isinstance(row.get("group_id"), str) or not row["group_id"]: |
| raise ValueError("group_id_missing") |
| record = dict(row["program"]) |
| if record["dsl"] != "plotqa_dsl_v1" or record["compile_status"] != "compiled": |
| raise ValueError("unsupported_program_contract") |
| |
| record.update(question_sha256="", choices_sha256="") |
| program = program_from_dict(record) |
| observed, renderer = row["observed_world"], row["renderer"] |
| if any( |
| type(renderer[k]) is not int or not 220 <= renderer[k] <= 4096 |
| for k in ("width", "height") |
| ): |
| raise ValueError("unsupported_canvas") |
| mask = observed["_node_visibility"] |
| if not mask or any(flag != "hidden" for flag in mask.values()): |
| raise ValueError("invalid_visibility_mask") |
| hidden = set(mask) |
| points = [p for s in observed["series"] for p in s["points"]] |
| if not hidden <= {p["id"] for p in points}: |
| raise ValueError("hidden_point_missing") |
| if any(p["y"] is not None for p in points if p["id"] in hidden): |
| raise ValueError("observed_hidden_value_present") |
| image = pixels(base64.b64decode(row["observed_png_base64"], validate=True)) |
| if image.shape != (renderer["height"], renderer["width"], 4): |
| raise ValueError("observed_image_dimensions") |
| primary, reference = PlotExecutor(), ReferencePlotExecutor() |
| missing = [ex.execute(program, world=observed).status for ex in (primary, reference)] |
| if missing != ["MISSING_INFORMATION", "MISSING_INFORMATION"]: |
| errors.append("observed_program_not_missing") |
| if not np.array_equal(pixels(render_direct(observed, renderer)["image"]), image): |
| errors.append("observed_world_pixels_mismatch") |
| for key in ("complete_witness_a", "complete_witness_b"): |
| world = copy.deepcopy(row[key]) |
| if world.get("_node_visibility"): |
| errors.append("complete_world_is_hidden") |
| if world["render_domain"] != observed["render_domain"]: |
| errors.append("fixed_axis_mismatch") |
| lo, hi = (Fraction(world["render_domain"][k]) for k in ("y_min", "y_max")) |
| if lo >= hi: |
| errors.append("invalid_axis_interval") |
| ids = [] |
| for series in world["series"]: |
| ids.append(series["id"]) |
| xs = [str(p["x"]) for p in series["points"]] |
| if len(xs) != len(set(xs)): |
| errors.append("duplicate_x_label") |
| for point in series["points"]: |
| ids.append(point["id"]) |
| if not lo <= Fraction(point["y"]) <= hi: |
| errors.append("complete_value_outside_axis") |
| if len(ids) != len(set(ids)): |
| errors.append("duplicate_node_id") |
| |
| render_direct(world, renderer) |
| a, b = (ex.execute(program, world=world) for ex in (primary, reference)) |
| if a.status != "UNIQUE" or (a.status, a.answer_canonical) != ( |
| b.status, |
| b.answer_canonical, |
| ): |
| errors.append("executor_failure") |
| answers.append(a.answer_canonical) |
| world["_node_visibility"] = copy.deepcopy(mask) |
| if visible_projection(world) != observed: |
| errors.append("visible_projection_mismatch") |
| if not np.array_equal(pixels(render_direct(world, renderer)["image"]), image): |
| errors.append("observed_pixels_mismatch") |
| if len(answers) != 2 or answers[0] == answers[1]: |
| errors.append("answers_not_distinct") |
| except Exception as exc: |
| errors.append(f"{type(exc).__name__}:{exc}") |
| return { |
| "group_id": row.get("group_id"), |
| "ok": not errors, |
| "answers": answers, |
| "errors": sorted(set(errors)), |
| } |
|
|
