Datasets:
File size: 6,584 Bytes
e1ced61 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | """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")
# Legacy dataclass envelope fields do not enter semantic execution.
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")
# Full visibility and label layout must actually render successfully.
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)),
}
|