Datasets:
File size: 7,370 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 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | """``plotqa_dsl_v1`` operator table + dataset-level PlotQA program compiler
(``docs/02`` §5.2, ``docs/07`` §4 P2).
The compiler is **dataset-level** (per-template, not per-example): each allowlisted
PlotQA template maps to a fixed typed-AST shape built in code from the QA's slot
metadata. No per-example human labeling, no execution, no model calls — those are
P3/P4. The ``TEMPLATE_DSL_MAPPING`` strings in :mod:`~explicit_learning.sources.plotqa`
are the human-readable reference for the same shapes built here as typed
:class:`~explicit_learning.dsl.ast.AstNode` trees.
Slot extraction reads ``item.provenance["slots"]`` (the QA's ``series`` / ``x`` /
``x1`` / ``x2`` slots, carried through ``normalize``). The series label is resolved
to its stable world id (``series:0``) so the program carries a real entity ``REF``;
the x value is a literal string (x-axis values are not tracked entities). An
unresolvable slot yields ``compile_status="unsupported"`` with a ``reason_code`` —
never a guessed program (``docs/02`` §5.2, runbook: no faked ``compiled``).
"""
from __future__ import annotations
from dataclasses import replace
from typing import Any
from ..ingest.base import NormalizedItem
from ..sources.base import World
from .ast import AstNode, Dsl, Program, lit, ref
from .canonicalize import canonical_program_sha256
from .typecheck import OpSignature, typecheck
DSL: Dsl = "plotqa_dsl_v1"
# --- operator signature table (§5.2) ---------------------------------------
#
# ``selector_kind``: "scalar" (exactly one referent), "set" (zero or more, so a
# zero-cardinality referent is NOT invalid — §11.3), or "none" (a value).
# ``LOOKUP``/``SUBTRACT`` are order-significant; ``SUM`` is variadic-commutative.
SIGNATURES: dict[str, OpSignature] = {
"SELECT_SERIES": OpSignature(
arg_types=("series",), return_type="series", selector_kind="scalar"
),
"SELECT_X": OpSignature(arg_types=("string",), return_type="x", selector_kind="scalar"),
"LOOKUP": OpSignature(arg_types=("series", "x"), return_type="value", selector_kind="none"),
"POINTS": OpSignature(arg_types=("series",), return_type="points", selector_kind="set"),
"ARGMAX": OpSignature(
arg_types=("points", "string"), return_type="point", selector_kind="scalar"
),
"ARGMIN": OpSignature(
arg_types=("points", "string"), return_type="point", selector_kind="scalar"
),
"SUBTRACT": OpSignature(
arg_types=("value", "value"), return_type="value", selector_kind="none"
),
"SUM": OpSignature(
arg_types=("any",),
return_type="value",
commutative=True,
variadic=True,
selector_kind="none",
),
"COUNT": OpSignature(arg_types=("points",), return_type="integer", selector_kind="set"),
"EXIST": OpSignature(arg_types=("points",), return_type="boolean", selector_kind="set"),
}
# Canonicalization profile (§7.2 steps 3–5).
COMMUTATIVE_OPS: frozenset[str] = frozenset({"SUM"})
ALIASES: dict[str, str] = {"GET_VALUE": "LOOKUP", "MAX": "ARGMAX", "MIN": "ARGMIN"}
IDENTITY_CASTS: frozenset[str] = frozenset({"TO_VALUE"})
_UNSUPPORTED_NODE = AstNode(op="UNSUPPORTED", args=(), return_type="")
# --- compile ---------------------------------------------------------------
def compile_plotqa(item: NormalizedItem, world: World) -> Program:
"""Build the typed ``plotqa_dsl_v1`` program for one normalized PlotQA item.
Returns a :class:`Program` with ``compile_status="compiled"`` (type-checked,
canonical hash filled) or ``"unsupported"`` (with a ``reason_code``) when a
slot is missing/unresolvable. Never guesses a program.
"""
prov = item.provenance
template = prov.get("template")
slots = prov.get("slots") or {}
series_id = _series_id_for_label(world, slots.get("series"))
if template == "T_LOOKUP":
x = slots.get("x")
if series_id is None or x is None:
return _unsupported(item, "t_lookup_missing_series_or_x")
program = _lookup(series_id, str(x))
referent = _select_series(series_id)
elif template == "T_DIFFERENCE":
x1, x2 = slots.get("x1"), slots.get("x2")
if series_id is None or x1 is None or x2 is None:
return _unsupported(item, "t_difference_missing_slots")
program = AstNode(
op="SUBTRACT",
args=(_lookup(series_id, str(x1)), _lookup(series_id, str(x2))),
return_type="value",
)
referent = _select_series(series_id)
elif template in ("T_MAX_YEAR", "T_MIN_YEAR"):
if series_id is None:
return _unsupported(item, f"{template.lower()}_missing_series")
op = "ARGMAX" if template == "T_MAX_YEAR" else "ARGMIN"
program = AstNode(op=op, args=(_points(series_id), "value"), return_type="point")
referent = _select_series(series_id)
elif template == "T_SUM":
if series_id is None:
return _unsupported(item, "t_sum_missing_series")
program = AstNode(op="SUM", args=(_points(series_id),), return_type="value")
referent = _select_series(series_id)
else:
return _unsupported(item, f"template_{template}_not_compilable")
program_node = typecheck(
Program(
dsl=DSL,
program=program,
base_id=item.base_id,
question_sha256=item.question_sha256,
choices_sha256=item.choices_sha256,
compile_status="compiled",
referent_selector=referent,
required_referent_cardinality=1,
),
world=world,
)
return replace(
program_node, canonical_program_sha256=canonical_program_sha256(program_node, world=world)
)
# --- AST builders ----------------------------------------------------------
def _select_series(series_id: str) -> AstNode:
return AstNode(
op="SELECT_SERIES", args=(ref(series_id, return_type="series"),), return_type="series"
)
def _select_x(x_label: str) -> AstNode:
return AstNode(op="SELECT_X", args=(lit(x_label, return_type="string"),), return_type="x")
def _lookup(series_id: str, x_label: str) -> AstNode:
return AstNode(
op="LOOKUP", args=(_select_series(series_id), _select_x(x_label)), return_type="value"
)
def _points(series_id: str) -> AstNode:
return AstNode(op="POINTS", args=(_select_series(series_id),), return_type="points")
def _unsupported(item: NormalizedItem, reason: str) -> Program:
return Program(
dsl=DSL,
program=_UNSUPPORTED_NODE,
base_id=item.base_id,
question_sha256=item.question_sha256,
choices_sha256=item.choices_sha256,
compile_status="unsupported",
reason_code=reason,
)
# --- world helpers ---------------------------------------------------------
def _series_id_for_label(world: World, label: Any) -> str | None:
"""Resolve a series label to its stable world id (``series:0``); None if absent."""
if not isinstance(label, str) or not label:
return None
for series in world.get("series", []) or []:
if isinstance(series, dict) and series.get("label") == label and series.get("id"):
return str(series["id"])
return None
__all__ = [
"ALIASES",
"COMMUTATIVE_OPS",
"DSL",
"IDENTITY_CASTS",
"SIGNATURES",
"compile_plotqa",
]
|