feat: audit source licenses and table footnotes

Extends the paper verifier past names and token counts: every source row in
the composition table is now checked against src/sources.py and against the
source's own datasheet, and the table's footnote markers are checked in both
directions (used but unexplained, explained but on no row).

License strings are compared by (family, version), so the paper may abbreviate
"CC-BY-4.0" to "CC-BY" and print public domain as either PD or CC0 without
tripping the check, while a genuine family or version mismatch fails.

The audit's one real hit: parliamentary is public-domain content (PL art. 4
pr. aut.) redistributed by IPI PAN under CC-BY-4.0, so the registry's `license`
and `license_spdx` disagree by design. A one-line cell that prints only one of
the two layers now has to carry a footnote.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SLqJTEbW4oU78vmBMPVQs2

src/test_verify_paper_claims.py

@@ -32,7 +32,7 @@ v0.1.1 & 3.00 & 2 \\
 \begin{tabular}{llr}
 Source & License & Tokens [M] \\
 \texttt{alpha}      & CC0       & 2000.0 \\
-\texttt{beta\_two}  & CC-BY-4.0 & 1000.0 \\
+\texttt{beta\_two}  & CC-BY-SA-4.0 & 1000.0 \\
 \textbf{Total} & CC-BY-SA-4.0 & \textbf{$\approx$3000} \\
 \end{tabular}
 \end{table}
@@ -56,18 +56,38 @@ TOKENS = [1_000_000_000, 3_000_000_000]
 
 STATS = {"alpha": (200, 2_000_000_000), "beta_two": (100, 1_000_000_000)}
 
+SOURCES = """SOURCES = {
+    "alpha": {"license": "CC0-1.0", "license_spdx": "CC0-1.0", "release": "0.1.0"},
+    "beta_two": {"license": "CC-BY-SA-4.0", "license_spdx": "CC-BY-SA-4.0", "release": "0.1.1"},
+}
+"""
+
+
+def registry(root: Path) -> dict:
+    return vpc.load_registry(root)
+
+
+def edit(path: Path, old: str, new: str) -> None:
+    text = path.read_text()
+    assert old in text, f"fixture no longer contains {old!r}"
+    path.write_text(text.replace(old, new))
+
 
 def build(root: Path) -> None:
     (root / "src").mkdir(parents=True)
     (root / "CHANGELOG.md").write_text(CHANGELOG)
     (root / "README.md").write_text(README)
     (root / "src" / "plot_version_growth.py").write_text(GROWTH)
+    (root / "src" / "sources.py").write_text(SOURCES)
     for name, (docs, tokens) in STATS.items():
         directory = root / "data" / name
         directory.mkdir(parents=True)
         (directory / f"{name}.stats.json").write_text(
             json.dumps({"kept": docs, "tokens": tokens, "license": "CC0"})
         )
+        (directory / f"{name}.md").write_text(
+            f"# {name}\n- **License:** `{registry(root)[name]['license']}`\n"
+        )
     (root / "paper.tex").write_text(TEX)
 
 
@@ -96,10 +116,40 @@ def wrong_source_count(root: Path) -> None:
     path.write_text(path.read_text().replace("v0.1.1 & 3.00 & 2", "v0.1.1 & 3.00 & ---"))
 
 
-def unlisted_source(root: Path) -> None:
+def add_source(root: Path, release: str | None) -> None:
     directory = root / "data" / "gamma"
     directory.mkdir(parents=True)
     (directory / "gamma.stats.json").write_text(json.dumps({"kept": 1, "tokens": 1, "license": "CC0"}))
+    (directory / "gamma.md").write_text("# gamma\n- **License:** `CC0-1.0`\n")
+    edit(root / "src" / "sources.py", "}\n",
+         f'    "gamma": {{"license": "CC0-1.0", "release": {release!r}}},\n}}\n')
+
+
+def unlisted_source(root: Path) -> None:
+    add_source(root, "0.1.1")
+
+
+def unreleased_source(root: Path) -> None:
+    add_source(root, None)
+
+
+def wrong_license(root: Path) -> None:
+    edit(root / "paper.tex", "CC-BY-SA-4.0 & 1000.0", "CC-BY-4.0 & 1000.0")
+
+
+def datasheet_license_drift(root: Path) -> None:
+    edit(root / "data" / "alpha" / "alpha.md", "CC0-1.0", "CC-BY-4.0")
+
+
+def undefined_footnote(root: Path) -> None:
+    edit(root / "paper.tex", "& CC0       &", r"& CC0$^{\dagger}$ &")
+
+
+def unfootnoted_dual_license(root: Path) -> None:
+    """alpha's content is CC0 but its platform redistributes under CC-BY-4.0."""
+    edit(root / "src" / "sources.py",
+         '"alpha": {"license": "CC0-1.0", "license_spdx": "CC0-1.0"',
+         '"alpha": {"license": "CC0-1.0", "license_spdx": "CC-BY-4.0"')
 
 
 def stale_growth_series(root: Path) -> None:
@@ -113,4 +163,9 @@ if __name__ == "__main__":
     assert scenario(wrong_source_count) == 1, "carried-over '---' source count must fail"
     assert scenario(unlisted_source) == 1, "source present in repo but not in Table 3 must fail"
     assert scenario(stale_growth_series) == 1, "growth series vs composition drift must fail"
+    assert scenario(unreleased_source) == 0, "a source with release=None is not part of the release"
+    assert scenario(wrong_license) == 1, "license in Table 3 vs registry must fail"
+    assert scenario(datasheet_license_drift) == 1, "datasheet vs registry license drift must fail"
+    assert scenario(undefined_footnote) == 1, "a footnote marker with no definition must fail"
+    assert scenario(unfootnoted_dual_license) == 1, "an unfootnoted dual license must fail"
     print("ok")

src/verify_paper_claims.py

@@ -36,6 +36,8 @@ TOL_MILLIONS = 0.05  # Table 3: 1 decimal place
 
 OK, FAIL, WARN = "OK", "FAIL", "WARN"
 
+MARKER = re.compile(r"\$\^\{([^}]*)\}\$")
+
 
 class Report:
     def __init__(self) -> None:
@@ -117,6 +119,31 @@ def parse_source_table(tex: str) -> tuple[dict[str, float], float | None]:
     return sources, total
 
 
+def parse_license_rows(tex: str) -> dict[str, tuple[str, set[str]]]:
+    """Table 3 source rows -> (license cell without its markers, marker names)."""
+    body = _table_body(tex, "tab:s05-zrodla").split(r"\begin{tabular}")[-1]
+    rows = {}
+    for name, cell in re.findall(r"\\texttt\{([^}]+)\}\s*&(.*?)&\s*[\d.]+\s*\\\\", body):
+        rows[_unescape(name)] = (MARKER.sub("", cell).strip(), _markers(cell))
+    return rows
+
+
+def parse_footnote_defs(tex: str) -> set[str]:
+    """Markers the Table 3 caption actually explains (a definition is followed by ~)."""
+    caption = _table_body(tex, "tab:s05-zrodla").split(r"\begin{tabular}")[0]
+    return {m for cell in re.findall(r"(\$\^\{[^}]*\}\$)~", caption) for m in _markers(cell)}
+
+
+def parse_total_license(tex: str) -> str | None:
+    body = _table_body(tex, "tab:s05-zrodla")
+    row = re.search(r"\\textbf\{Total\}\s*&\s*(.*?)\s*&", body)
+    return MARKER.sub("", row.group(1)).strip() if row else None
+
+
+def _markers(cell: str) -> set[str]:
+    return {m for group in MARKER.findall(cell) for m in re.findall(r"\\([a-zA-Z]+)", group)}
+
+
 def parse_inline_claims(tex: str, current: str | None = None) -> dict:
     """Claims the prose/captions make about the *current release* totals.
 
@@ -183,13 +210,11 @@ def load_growth_series(root: Path) -> dict[str, tuple[int, int]]:
     return dict(zip(found["VERSIONS"], zip(found["DOCUMENTS"], found["TOKENS"])))
 
 
-def load_release_map(root: Path) -> dict[str, str | None]:
-    """Source name -> the release it entered, from the src/sources.py registry.
+def load_registry(root: Path) -> dict[str, dict]:
+    """The SOURCES table from src/sources.py, read without importing the module.
 
-    Empty when the registry is absent or predates the `release` field, in which
-    case the CHANGELOG prose stays the only ground truth. The registry is always
-    read from the working tree: it defines what a release *is*, independently of
-    the ref the parquet stats are read from.
+    Always read from the working tree: the registry defines what a release *is*,
+    independently of the ref the parquet stats are read from.
     """
     path = root / "src" / "sources.py"
     if not path.exists():
@@ -197,10 +222,17 @@ def load_release_map(root: Path) -> dict[str, str | None]:
     for node in ast.parse(path.read_text(encoding="utf-8")).body:
         if (isinstance(node, ast.Assign) and len(node.targets) == 1
                 and getattr(node.targets[0], "id", None) == "SOURCES"):
-            sources = ast.literal_eval(node.value)
-            break
-    else:
-        return {}
+            return ast.literal_eval(node.value)
+    return {}
+
+
+def load_release_map(root: Path) -> dict[str, str | None]:
+    """Source name -> the release it entered.
+
+    Empty when the registry is absent or predates the `release` field, in which
+    case the CHANGELOG prose stays the only ground truth.
+    """
+    sources = load_registry(root)
     if not any("release" in cfg for cfg in sources.values()):
         return {}
     return {name: cfg.get("release") for name, cfg in sources.items()}
@@ -419,6 +451,98 @@ def check_composition(report: Report, tex: str, root: Path, ref: str) -> None:
                series[last][0], sum_docs)
 
 
+def norm_license(text: str) -> tuple[str, str | None]:
+    """Canonical (family, version) so paper, registry and datasheet can be compared.
+
+    Public domain and CC0 are one family: SPDX spells "official documents are
+    outside copyright" as CC0-1.0, and the paper prints both as PD. A version of
+    None means the text states no version, and compares equal to any version --
+    the paper abbreviates nkjp1m's CC-BY-4.0 to "CC-BY" on purpose.
+    """
+    t = re.sub(r"[`_]", " ", text).upper()
+    if re.search(r"PER-RECORD|PER-DOCUMENT|MIXED", t):
+        return ("MIXED", None)
+    if re.search(r"CC0|PUBLIC[- ]DOMAIN|\bPD\b", t):
+        return ("PD/CC0", None)
+    match = re.search(r"CC[- ]BY(?:[- ](SA))?(?:[- ](\d+\.\d+))?", t)
+    if match:
+        return ("CC-BY-SA" if match.group(1) else "CC-BY", match.group(2))
+    return (t.strip(), None)
+
+
+def compatible(a: tuple[str, str | None], b: tuple[str, str | None]) -> bool:
+    """Same family, and same version unless one side states none."""
+    return a[0] == b[0] and (a[1] is None or b[1] is None or a[1] == b[1])
+
+
+def load_datasheet_license(root: Path, name: str) -> str | None:
+    """The datasheet's declared License line (working tree, not the pinned ref)."""
+    path = root / "data" / name / f"{name}.md"
+    if not path.exists():
+        return None
+    match = re.search(r"\*\*License:\*\*\s*(.+)", path.read_text(encoding="utf-8"))
+    return match.group(1).strip() if match else None
+
+
+def check_licenses(report: Report, tex: str, root: Path) -> None:
+    report.section("Check 3 - licenses and footnotes (Table 3 vs registry vs datasheets)")
+
+    rows = parse_license_rows(tex)
+    registry = load_registry(root)
+    if not registry:
+        report.add(WARN, "license audit", "src/sources.py carries no registry to compare against")
+        return
+
+    for name in sorted(rows, key=lambda n: n.lower()):
+        paper, markers = rows[name]
+        cfg = registry.get(name)
+        if cfg is None:
+            report.add(FAIL, f"{name} in registry", "listed in Table 3 but absent from src/sources.py")
+            continue
+
+        declared = norm_license(str(cfg.get("license", "")))
+        spdx = norm_license(str(cfg.get("license_spdx") or cfg.get("license", "")))
+        printed = norm_license(paper)
+
+        if compatible(printed, declared) or compatible(printed, spdx):
+            report.add(OK, f"{name} license", f"{paper} == {cfg.get('license')}")
+        else:
+            report.add(FAIL, f"{name} license",
+                       f"paper {paper!r} != registry {cfg.get('license')!r} / {cfg.get('license_spdx')!r}")
+
+        sheet = load_datasheet_license(root, name)
+        if sheet is None:
+            report.add(WARN, f"{name} datasheet license", "no **License:** line in the datasheet")
+        elif not compatible(norm_license(sheet), declared):
+            report.add(FAIL, f"{name} datasheet license",
+                       f"datasheet {sheet!r} != registry {cfg.get('license')!r}")
+
+        # A source whose content license differs from its redistribution license
+        # states only half the story in a one-line cell; the footnote carries the rest.
+        if not compatible(declared, spdx) and not markers:
+            report.add(FAIL, f"{name} dual license is footnoted",
+                       f"content {cfg.get('license')!r} but redistributed as "
+                       f"{cfg.get('license_spdx')!r}; the row prints only {paper!r}")
+
+    used = {m for _, markers in rows.values() for m in markers}
+    defined = parse_footnote_defs(tex)
+    if used - defined:
+        report.add(FAIL, "every footnote marker is defined", f"used but not explained: {sorted(used - defined)}")
+    elif defined - used:
+        report.add(FAIL, "every footnote is used", f"explained but on no row: {sorted(defined - used)}")
+    else:
+        report.add(OK, "footnote markers", f"{len(used)} defined and used: {sorted(used)}")
+
+    total = parse_total_license(tex)
+    strongest = [n for n, (lic, _) in rows.items() if norm_license(lic)[0] == "CC-BY-SA"]
+    if total is None:
+        report.add(WARN, "Total row license", "no license cell in the Total row")
+    elif strongest and norm_license(total)[0] != "CC-BY-SA":
+        report.add(FAIL, "Total row license", f"{total} does not inherit the share-alike of {sorted(strongest)}")
+    else:
+        report.add(OK, "Total row license", f"{total} inherits share-alike from {len(strongest)} sources")
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__,
                                      formatter_class=argparse.RawDescriptionHelpFormatter)
@@ -436,6 +560,7 @@ def main(argv: list[str] | None = None) -> int:
     report = Report()
     check_trajectory(report, tex, root)
     check_composition(report, tex, root, ref)
+    check_licenses(report, tex, root)
     return report.render()