code/verify.py

#!/usr/bin/env python3
"""Independent source/algebra auditor. Does not import build.py or its oracle."""
import argparse
import collections
from decimal import Decimal, ROUND_HALF_UP
import hashlib
import json
import pathlib

EXPECTED = {
 "SP.POP.TOTL": ("persons", "quantity"),
 "NY.GDP.MKTP.CD": ("current_USD", "quantity"),
 "NY.GDP.PCAP.CD": ("current_USD_per_person", "quantity"),
 "NY.GDP.MKTP.KD.ZG": ("percent_annual_GDP_growth", "rate"),
 "SP.DYN.LE00.IN": ("years", "quantity"),
 "EG.ELC.ACCS.ZS": ("percent_population_electricity", "rate"),
 "FP.CPI.TOTL.ZG": ("percent_annual_CPI_inflation", "rate"),
 "SP.URB.TOTL.IN.ZS": ("percent_population_urban", "rate"),
}


def normalized_decimal(value, round_derived=False):
    value = Decimal(value)
    if round_derived:
        value = value.quantize(Decimal("0.000001"), rounding=ROUND_HALF_UP)
    if value.is_zero():
        return "0"
    text = format(value, "f")
    return text.rstrip("0").rstrip(".") if "." in text else text


def evaluate(operator, rows):
    """A separate algebra implementation over model-visible rows only."""
    assert rows and len({r["cell_id"] for r in rows}) == len(rows), "empty/repeated evidence cells"
    if operator == "incompatible_sum":
        assert len(rows) == 2 and rows[0]["unit_code"] != rows[1]["unit_code"], "compatible sum mislabeled"
        return dict(status="incompatible_units", value=None, unit=None)
    unit = rows[0]["unit_code"]
    if operator == "lookup":
        assert len(rows) == 1
        return dict(status="missing" if rows[0]["value"] is None else "ok", value=rows[0]["value"], unit=unit)
    assert all(r["value"] is not None for r in rows), "non-lookup task uses missing source value"
    amounts = [Decimal(r["value"]) for r in rows]
    if operator == "gdp_per_capita_join":
        assert len(rows) == 2
        assert rows[0]["indicator_code"] == "NY.GDP.MKTP.CD" and rows[1]["indicator_code"] == "SP.POP.TOTL"
        assert rows[0]["year"] == rows[1]["year"] and rows[0]["economy_code"] == rows[1]["economy_code"]
        assert amounts[1] > 0
        return dict(status="ok", value=normalized_decimal(amounts[0] / amounts[1], True), unit="current_USD_per_person_calculated")
    assert len({r["indicator_code"] for r in rows}) == 1, "unrelated indicators compared"
    if operator in ("maximum_years", "minimum_years", "second_highest_years"):
        assert len({r["economy_code"] for r in rows}) == 1
        assert len({r["year"] for r in rows}) == len(rows)
        distinct = sorted(set(amounts))
        if operator == "minimum_years":
            chosen = distinct[0]
        elif operator == "maximum_years":
            chosen = distinct[-1]
        else:
            assert len(distinct) >= 2
            chosen = distinct[-2]
        years = sorted(row["year"] for row, value in zip(rows, amounts) if value == chosen)
        return dict(status="ok", value=years, unit="year")
    assert len(rows) == 2 and rows[0]["unit_code"] == rows[1]["unit_code"]
    if operator == "greater_than":
        assert rows[0]["economy_code"] == rows[1]["economy_code"] or rows[0]["year"] == rows[1]["year"]
        return dict(status="ok", value=amounts[0] > amounts[1], unit="boolean")
    assert rows[0]["economy_code"] == rows[1]["economy_code"]
    assert int(rows[0]["year"]) < int(rows[1]["year"])
    if operator == "difference":
        assert rows[0]["measure_kind"] == "quantity"
        result, output_unit = amounts[1] - amounts[0], unit
    elif operator == "percentage_point_difference":
        assert rows[0]["measure_kind"] == "rate"
        result, output_unit = amounts[1] - amounts[0], "percentage_points"
    elif operator == "relative_change":
        assert rows[0]["measure_kind"] == "quantity" and amounts[0] > 0
        result, output_unit = Decimal(100) * (amounts[1] / amounts[0] - Decimal(1)), "percent_change"
    else:
        raise AssertionError("Unknown operator: " + operator)
    return dict(status="ok", value=normalized_decimal(result, True), unit=output_unit)


def read_lines(path):
    return [json.loads(line) for line in path.read_text().splitlines() if line]


def audit(release, raw=None):
    release = pathlib.Path(release)
    raw = pathlib.Path(raw) if raw else release / "raw"
    manifest = json.loads((raw / "manifest.json").read_text())
    assert set(manifest["series"]) == set(EXPECTED)
    for entry in manifest["files"]:
        assert hashlib.sha256((raw / entry["file"]).read_bytes()).hexdigest() == entry["sha256"], "raw digest mismatch"
    source = {}
    for code in EXPECTED:
        meta = json.loads((raw / f"{code}.metadata.json").read_text())
        fields = {m["id"]: m["value"] for m in meta["source"][0]["concept"][0]["variable"][0]["metatype"]}
        assert fields["License_Type"] == "CC BY-4.0" and fields["License_URL"] == "https://datacatalog.worldbank.org/public-licenses#cc-by"
        assert fields["Source"] and fields["Unitofmeasure"]
        path = raw / f"{code}.observations.json"
        snapshot_sha = hashlib.sha256(path.read_bytes()).hexdigest()
        header, rows = json.loads(path.read_text(), parse_float=Decimal)
        assert str(header["sourceid"]) == "2" and header["pages"] == 1 and header["total"] == len(rows)
        assert len(rows) == 550
        for row in rows:
            source[(row["countryiso3code"], code, row["date"])] = (row, snapshot_sha)
    observation_rows, questions, tables = [], [], []
    for split in ("train", "validation", "test"):
        for config, target in [("observations", observation_rows), ("questions", questions), ("tables", tables)]:
            rows = read_lines(release / "jsonl" / config / f"{split}.jsonl")
            assert all(row["split"] == split for row in rows)
            target.extend(rows)
            import pyarrow.parquet as pq
            loaded = pq.read_table(release / "data" / config / f"{split}-00000-of-00001.parquet").to_pylist()
            assert loaded == rows, "Parquet differs from corresponding JSONL"
    assert len(observation_rows) == len(source) == 4400
    assert len({x["cell_id"] for x in observation_rows}) == len(observation_rows)
    observed = {x["cell_id"]: x for x in observation_rows}
    economy_splits = collections.defaultdict(set)
    source_keys = set()
    for row in observation_rows:
        key = (row["economy_code"], row["indicator_code"], row["year"])
        assert key not in source_keys
        source_keys.add(key)
        upstream, sha = source[key]
        expected_value = None if upstream["value"] is None else normalized_decimal(upstream["value"])
        assert row["value"] == expected_value and row["source_snapshot_sha256"] == sha
        expected_id = "c_" + hashlib.sha256(json.dumps(["2", key[1], key[0], key[2], sha], ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:24]
        assert row["cell_id"] == expected_id
        assert row["economy_ar"] == upstream["country"]["value"] and row["source_obs_status"] == upstream["obs_status"]
        assert (row["unit_code"], row["measure_kind"]) == EXPECTED[row["indicator_code"]]
        economy_splits[row["economy_code"]].add(row["split"])
    assert all(len(value) == 1 for value in economy_splits.values()), "economy crosses splits"
    table_map = {row["table_id"]: row for row in tables}
    assert len(table_map) == len(tables)
    assert len({q["id"] for q in questions}) == len(questions)
    fingerprints, family_splits, used_cells = set(), collections.defaultdict(set), collections.defaultdict(set)
    visible_keys = {"cell_id", "economy_code", "economy_ar", "indicator_code", "indicator_ar", "year", "value", "unit_code", "unit_ar", "measure_kind"}
    operations = collections.Counter()
    for q in questions:
        assert "gold" not in q["context"] and "program" not in q["context"]
        context = json.loads(q["context"])
        assert set(context) == {"caption_ar", "source", "cells"}
        table = table_map[q["table_id"]]
        assert table["context"] == q["context"] and table["split"] == q["split"]
        for cell in context["cells"]:
            assert set(cell) == visible_keys
            assert cell == {key: observed[cell["cell_id"]][key] for key in visible_keys}, "context differs from source observation"
            assert observed[cell["cell_id"]]["split"] == q["split"], "source cell crosses task splits"
            used_cells[cell["cell_id"]].add(q["split"])
        program = json.loads(q["program"])
        assert program["operator"] == q["operation"]
        assert program["derived_decimal_places"] == 6 and program["rounding"] == "ROUND_HALF_UP"
        assert program["cells"] == [r["cell_id"] for r in context["cells"]] == q["gold_evidence_ids"]
        answer = evaluate(q["operation"], context["cells"])
        assert json.loads(q["gold_answer"]) == answer, "independent answer mismatch: " + q["id"]
        if q["structure_holdout_diagnostic"]:
            assert q["split"] == "test" and q["operation"] == "second_highest_years"
        if q["operation"] == "second_highest_years":
            assert q["structure_holdout_diagnostic"]
        fingerprint = (q["context"], q["question_ar"])
        assert fingerprint not in fingerprints, "duplicate input"
        fingerprints.add(fingerprint)
        family_splits[q["family_id"]].add(q["split"])
        operations[q["operation"]] += 1
        from model_input import model_input
        allowed_input = model_input(q)
        assert set(allowed_input) == {"question_ar", "table"} and allowed_input["table"] == context
    assert all(len(x) == 1 for x in used_cells.values()) and all(len(x) == 1 for x in family_splits.values())
    return {"passed": True, "source_observations": len(source), "questions": len(questions), "tables": len(tables),
            "source_cells_used_in_questions": len(used_cells), "source_cell_split_overlap": 0,
            "economy_split_overlap": 0, "exact_duplicate_inputs": 0, "independent_answer_mismatches": 0,
            "parquet_jsonl_equal": True, "operations": dict(operations),
            "scope": "Software and source-contract verification only; no human linguistic/statistical review or learned-model accuracy claim."}


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--release", type=pathlib.Path, required=True)
    parser.add_argument("--raw", type=pathlib.Path)
    parser.add_argument("--output", type=pathlib.Path)
    args = parser.parse_args()
    report = audit(args.release, args.raw)
    if args.output:
        args.output.parent.mkdir(parents=True, exist_ok=True)
        args.output.write_text(json.dumps(report, indent=2) + "\n")
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()