Upload folder using huggingface_hub

README.md

@@ -1,3 +1,214 @@
 ---
-license: mit
+language:
+- en
+license: other
+pretty_name: XL-DocBench
+task_categories:
+- question-answering
+tags:
+- document-understanding
+- long-context
+- multimodal-document-ai
+- cross-document-qa
+- benchmark
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: single_doc
+  default: true
+  data_files:
+  - split: test
+    path: data/qa_single_doc.jsonl
+- config_name: cross_doc
+  data_files:
+  - split: test
+    path: data/qa_cross_doc.jsonl
+- config_name: documents
+  data_files:
+  - split: documents
+    path: data/documents.jsonl
+- config_name: scores
+  data_files:
+  - split: results
+    path: results/scores.jsonl
 ---
+
+<div align="center">
+
+<h1>XL-DocBench</h1>
+
+<p>
+  Evidence-grounded reasoning across hundreds or thousands of pages.<br>
+  Fully verified by 194 human experts.
+</p>
+
+<p>
+  Hongchen Wei<sup>1,†,‡</sup>, Yuanzhe Wang<sup>2,†,‡</sup>,
+  Bei Liu<sup>2,*</sup>, Yifan Yang<sup>2</sup>, Qi Dai<sup>2</sup>,
+  Ruichun Ma<sup>2</sup>, Kai Qiu<sup>2</sup>, Yunsheng Li<sup>2</sup>,<br>
+  Dongdong Chen<sup>2</sup>, Chong Luo<sup>2</sup>,
+  Zhenzhong Chen<sup>1</sup>, Baining Guo<sup>2</sup>
+</p>
+
+<p>
+  <sup>1</sup>Wuhan University &nbsp; <sup>2</sup>Microsoft &nbsp;
+  <sup>†</sup>Equal contribution &nbsp; <sup>‡</sup>Work done during an internship at MSRA &nbsp;
+  <sup>*</sup>Project leader
+</p>
+
+<p>
+  <a href="https://officeintelligence.github.io/xl-docbench/"><b>Project Page</b></a> ·
+  <a href="https://arxiv.org/abs/2608.00036"><b>Paper</b></a> ·
+  <a href="https://officeintelligence.github.io/xl-docbench/#leaderboard"><b>Live Leaderboard</b></a>
+</p>
+
+<p>
+  <a href="https://arxiv.org/abs/2608.00036"><img src="https://img.shields.io/badge/arXiv-2608.00036-b31b1b.svg" alt="arXiv"></a>
+  <img src="https://img.shields.io/badge/questions-1,345-3b5b92.svg" alt="1,345 questions">
+  <img src="https://img.shields.io/badge/documents-292-6a4c93.svg" alt="292 documents">
+  <img src="https://img.shields.io/badge/human_verified-194_experts-2d6a4f.svg" alt="Verified by 194 experts">
+</p>
+
+</div>
+
+## TL;DR
+
+This is the **conservative XL-DocBench release**. It contains
+**1,345 QA rows over 292 documents** after
+removing every question that touches an exact source URL marked
+`RAG: Not Approved`.
+
+## This release
+
+**292 documents** · **1,191 single-document QA** ·
+**154 cross-document QA** · **1,345 total QA**
+
+- `data/documents.jsonl`: retained document metadata and source URLs.
+- `data/qa_single_doc.jsonl`: retained single-document questions.
+- `data/qa_cross_doc.jsonl`: retained cross-document questions.
+- `manifest.json`: recomputed release statistics.
+- `results/scores.jsonl`: per-question scores for the 13 reproducible systems.
+- `results/summary.json`: aggregate scores for the same systems.
+- `code/quickstart.py`: one-command data and evaluator smoke test.
+- `code/evaluate.py`: self-contained deterministic evaluator.
+
+The filter uses exact URL matching. This variant addresses exact `Not Approved`
+RAG rows only and does not interpret separate `Portions Approved` entries.
+
+## About XL-DocBench
+
+XL-DocBench asks systems to **find the evidence, combine all required support,
+apply the right rule, and know when to abstain**. This strict release contains
+1,345 expert-verified questions from six professional domains. Among 1,280
+records with parseable historical human page annotations, 975 (76.2%) use
+multiple evidence pages. Released supporting evidence is multimodal for 429
+questions (31.9%), 154 questions (11.4%) use cross-document contexts, and 188
+require a `None` answer. Full-series contexts reach 2,935 pages.
+
+## Reproducible strict results
+
+All systems below have complete scores for the 1,345 retained IDs and use the
+hardened evaluator shipped in this release.
+
+| Rank | System | Input | Accuracy ↑ | Token F1 ↑ | ANLS ↑ |
+|---:|---|:---:|---:|---:|---:|
+| 1 | **GPT-5.4** | OCR | **38.36** | **39.70** | **34.17** |
+| 2 | SimpleDoc + GPT-5.4 | Agent | 36.21 | 33.62 | 24.30 |
+| 3 | Kimi-K2.5 | OCR | 36.06 | 38.24 | 32.64 |
+| 4 | MDocAgent + GPT-5.4 | Agent | 31.82 | 30.58 | 22.64 |
+| 5 | GPT-5.2 | OCR | 31.15 | 33.69 | 28.51 |
+| 6 | DeepSeek-V3.2 | OCR | 29.67 | 32.99 | 28.91 |
+| 7 | Qwen3.5-4B | OCR | 29.00 | 32.23 | 28.13 |
+| 8 | DeepRead + GPT-5.4 | Agent | 27.73 | 26.99 | 21.17 |
+| 9 | GPT-5.4 | Img | 26.77 | 29.76 | 26.33 |
+| 10 | Kimi-K2.5 | Img | 26.02 | 27.59 | 23.04 |
+| 11 | GPT-5.2 | Img | 21.71 | 24.95 | 21.92 |
+| 12 | Qwen3.5-4B | Img | 20.52 | 20.86 | 18.26 |
+| 13 | Qwen3.5-9B | Img | 20.22 | 22.69 | 20.18 |
+
+## Per-question scores
+
+Source documents are referenced by public URLs rather than redistributed.
+Because some URLs may change or become unavailable over time, we also provide
+the benchmark scores for every retained question ID. This gives future users a
+stable comparison point even when a source URL is temporarily unavailable.
+
+- `results/scores.jsonl`: one row for each of the 1,345 question IDs.
+- `results/summary.json`: aggregate Accuracy, Token F1, and ANLS.
+
+Scores are stored on a 0-to-1 scale. 
+
+## Quick start
+
+Validate the complete release and run a five-question evaluation fixture:
+
+```bash
+uv run --no-project python code/quickstart.py
+```
+
+Load all three JSONL tables with the included standard-library example:
+
+```bash
+uv run --no-project python code/examples/load_data.py
+```
+
+## Evaluation
+
+Try the bundled five-question example:
+
+```bash
+uv run --no-project python code/evaluate.py \
+  --gold-files code/examples/gold_sample.jsonl \
+  --predictions code/examples/predictions_sample.jsonl
+```
+
+For a complete run, provide one prediction per question:
+
+```jsonl
+{"question_id": "adubench_single_000001", "prediction": "the biggest single risk to human health worldwide"}
+{"question_id": "adubench_cross_000001", "prediction": "macroprudential measures"}
+```
+
+```bash
+uv run --no-project python code/evaluate.py \
+  --predictions predictions.jsonl \
+  --output eval_report.json \
+  --per-question-csv per_question.csv
+```
+
+The evaluator reports rule-based **Accuracy**, token-level **F1**, and **ANLS**.
+Missing, failed, and unparsable predictions count as incorrect unless
+`--ignore-missing` is enabled.
+
+## Record structure
+
+```text
+question
+├── answer: value + format + verification rule
+├── document / documents
+│   ├── document_id + public URL
+│   ├── evidence_pages: one-based PDF/release page indices
+│   └── evidence_items: annotator locator + page references + excerpt kind
+└── metadata: domain + difficulty + reasoning type + answerability
+```
+
+`evidence_pages` locate pages in the released PDF context. Evidence-item
+`pages` preserve annotator-supplied page references; printed pagination can
+differ from PDF indices. The `page_numbering` and `evidence_kind` fields make
+those cases explicit. Row-level `unassigned_evidence_items` are retained as
+provenance and are not counted as released supporting evidence.
+
+PDF binaries and local filenames are not included. Source documents remain
+subject to their original licenses and terms; this release does not grant
+redistribution rights for third-party PDFs.
+
+## Citation
+
+```bibtex
+@article{wei2026xldocbench,
+  title   = {XL-DocBench: Benchmarking Evidence-Grounded Extra-Long Document Understanding},
+  author  = {Wei, Hongchen and Wang, Yuanzhe and Liu, Bei and Yang, Yifan and Dai, Qi and Ma, Ruichun and Qiu, Kai and Li, Yunsheng and Chen, Dongdong and Luo, Chong and Chen, Zhenzhong and Guo, Baining},
+  journal = {arXiv preprint arXiv:2608.00036},
+  year    = {2026}
+}
+```

code/README.md

@@ -0,0 +1,34 @@
+# XL-DocBench Code
+
+All runnable code is kept in this directory. The release smoke test and
+evaluator require only Python's standard library.
+
+## One-command smoke test
+
+Run from the release root:
+
+```bash
+uv run --no-project python code/quickstart.py
+```
+
+This validates the data files, IDs, document references, evidence metadata,
+per-question score coverage, manifest counts, and a five-question evaluation
+fixture.
+
+## Files
+
+- `quickstart.py`: zero-dependency release validation and evaluation smoke test.
+- `evaluate.py`: primary Accuracy, Token F1, and ANLS evaluator.
+- `examples/load_data.py`: minimal standard-library data loader.
+- `examples/gold_sample.jsonl`: five-record evaluation fixture.
+- `examples/predictions_sample.jsonl`: perfect predictions for that fixture.
+
+## Examples
+
+```bash
+uv run --no-project python code/examples/load_data.py
+
+uv run --no-project python code/evaluate.py \
+  --gold-files code/examples/gold_sample.jsonl \
+  --predictions code/examples/predictions_sample.jsonl
+```

code/evaluate.py

@@ -0,0 +1,638 @@
+#!/usr/bin/env python3
+"""Evaluate XL-DocBench predictions.
+
+This script is intentionally self-contained for public release. It computes the
+deterministic metrics used in the benchmark tables: relaxed Accuracy,
+token-level F1, and ANLS. It does not call any model or require private files.
+
+Prediction JSONL format:
+    {"question_id": "adubench_single_000001", "prediction": "..."}
+
+The prediction field may also be named ``model_answer``, ``answer``,
+``response``, or ``output``. JSON files are also accepted, including mappings
+from question_id to answer or internal-style ``{"items": {...}}`` files.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+ANSWER_FORMAT_MAP = {
+    "Str": "entity",
+    "Int": "numeric",
+    "Float": "numeric",
+    "None": "unanswerable",
+    "Bool": "boolean",
+    "Boolean": "boolean",
+    "Percentage": "percentage",
+}
+
+PREDICTION_FIELDS = ("prediction", "model_answer", "answer", "response", "output")
+QUESTION_ID_FIELDS = ("question_id", "global_qa_id", "global_id", "id")
+SUCCESS_STATUSES = {"success", "ok", "completed"}
+
+
+@dataclass
+class MetricBucket:
+    accuracy: list[float] = field(default_factory=list)
+    token_f1: list[float] = field(default_factory=list)
+    anls: list[float] = field(default_factory=list)
+
+    def add(self, accuracy: float, token_f1: float, anls: float) -> None:
+        self.accuracy.append(accuracy)
+        self.token_f1.append(token_f1)
+        self.anls.append(anls)
+
+    def summary(self) -> dict[str, float | int]:
+        return {
+            "count": len(self.accuracy),
+            "accuracy": average(self.accuracy),
+            "token_f1": average(self.token_f1),
+            "anls": average(self.anls),
+        }
+
+
+def average(values: list[float]) -> float:
+    return round(sum(values) / len(values), 6) if values else 0.0
+
+
+def load_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON on {path}:{line_number}") from exc
+            if not isinstance(value, dict):
+                raise TypeError(f"Expected object on {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def load_json_or_jsonl(path: Path) -> Any:
+    if path.suffix.lower() == ".jsonl":
+        return load_jsonl(path)
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def get_question_id(row: dict[str, Any]) -> str:
+    for field_name in QUESTION_ID_FIELDS:
+        value = row.get(field_name)
+        if value is not None and str(value).strip():
+            return str(value).strip()
+    return ""
+
+
+def string_value(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (str, int, float, bool)):
+        return str(value)
+    return json.dumps(value, ensure_ascii=False, sort_keys=True)
+
+
+def answer_payload(row: dict[str, Any]) -> dict[str, Any]:
+    value = row.get("answer", {})
+    return value if isinstance(value, dict) else {"value": value}
+
+
+def gold_answer(row: dict[str, Any]) -> str:
+    return string_value(answer_payload(row).get("value", ""))
+
+
+def answer_format(row: dict[str, Any]) -> str:
+    payload = answer_payload(row)
+    raw_format = string_value(payload.get("format", "Str")) or "Str"
+    verification_rule = string_value(payload.get("verification_rule", ""))
+    if verification_rule == "choice_exact_match":
+        return "single_choice"
+    if verification_rule == "percentage_exact":
+        return "percentage"
+    if raw_format in ANSWER_FORMAT_MAP:
+        return ANSWER_FORMAT_MAP[raw_format]
+    if "numeric" in verification_rule or "tolerance" in verification_rule:
+        return "numeric"
+    return raw_format.lower()
+
+
+def metadata(row: dict[str, Any]) -> dict[str, Any]:
+    value = row.get("metadata", {})
+    return value if isinstance(value, dict) else {}
+
+
+def load_gold_records(gold_files: list[Path]) -> dict[str, dict[str, Any]]:
+    if not gold_files:
+        raise ValueError("At least one gold file is required")
+
+    records: dict[str, dict[str, Any]] = {}
+    for path in gold_files:
+        for row in load_jsonl(path):
+            question_id = get_question_id(row)
+            if not question_id:
+                raise ValueError(f"Missing question_id in {path}")
+            if question_id in records:
+                raise ValueError(f"Duplicate question_id in gold data: {question_id}")
+            records[question_id] = row
+    if not records:
+        raise ValueError("No gold records found")
+    return records
+
+
+def extract_prediction(row: Any, prediction_field: str = "") -> str:
+    if not isinstance(row, dict):
+        return string_value(row)
+
+    if prediction_field:
+        if prediction_field not in row:
+            raise ValueError(f"Prediction field not found: {prediction_field}")
+        value = row[prediction_field]
+        if isinstance(value, dict) and "value" in value:
+            return string_value(value["value"])
+        return string_value(value)
+
+    for field_name in PREDICTION_FIELDS:
+        if field_name not in row:
+            continue
+        value = row[field_name]
+        if field_name == "answer" and isinstance(value, dict):
+            return string_value(value.get("value", ""))
+        return string_value(value)
+    return ""
+
+
+def load_predictions(
+    path: Path, prediction_field: str = ""
+) -> tuple[dict[str, str], dict[str, str]]:
+    payload = load_json_or_jsonl(path)
+    predictions: dict[str, str] = {}
+    statuses: dict[str, str] = {}
+
+    def add(question_id: str, value: Any) -> None:
+        if not question_id:
+            raise ValueError(f"Prediction row is missing a question id: {value!r}")
+        if question_id in predictions:
+            raise ValueError(f"Duplicate question_id in predictions: {question_id}")
+        predictions[question_id] = extract_prediction(value, prediction_field)
+        if isinstance(value, dict):
+            statuses[question_id] = (
+                string_value(value.get("status", "success")) or "success"
+            )
+        else:
+            statuses[question_id] = "success"
+
+    if isinstance(payload, list):
+        for row in payload:
+            if not isinstance(row, dict):
+                raise TypeError("Prediction JSONL/list rows must be objects")
+            add(get_question_id(row), row)
+    elif isinstance(payload, dict) and isinstance(payload.get("items"), dict):
+        for question_id, row in payload["items"].items():
+            add(str(question_id), row)
+    elif isinstance(payload, dict) and get_question_id(payload):
+        add(get_question_id(payload), payload)
+    elif isinstance(payload, dict):
+        for question_id, row in payload.items():
+            add(str(question_id), row)
+    else:
+        raise TypeError("Unsupported prediction file format")
+
+    return predictions, statuses
+
+
+def normalize_answer(text: str) -> str:
+    text = text.strip().lower()
+    for prefix in ("the answer is", "answer:", "answer is"):
+        if text.startswith(prefix):
+            text = text[len(prefix) :].strip()
+    text = re.sub(r"[^\w\s\.\-\%]", "", text)
+    text = re.sub(r"\b(a|an|the)\b", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def extract_number(text: str) -> float | None:
+    compact = text.replace(" ", "")
+
+    power_match = re.search(
+        r"(?P<base>[-+]?(?:\d+(?:\.\d+)?|\.\d+))\^(?P<exponent>[-+]?\d+)",
+        compact,
+    )
+    if power_match:
+        try:
+            return float(power_match.group("base")) ** int(
+                power_match.group("exponent")
+            )
+        except (OverflowError, ValueError):
+            return None
+
+    fraction_match = re.search(
+        r"(?P<numerator>[-+]?(?:\d+(?:\.\d+)?|\.\d+))/(?P<denominator>[-+]?(?:\d+(?:\.\d+)?|\.\d+))",
+        compact,
+    )
+    if fraction_match:
+        try:
+            denominator = float(fraction_match.group("denominator"))
+            if denominator == 0:
+                return None
+            return float(fraction_match.group("numerator")) / denominator
+        except ValueError:
+            return None
+
+    match = re.search(
+        r"[-+]?(?:\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:[.,]\d+)?|\.\d+)(?:[eE][-+]?\d+)?",
+        compact,
+    )
+    if not match:
+        return None
+    token = match.group()
+    if "," in token and "." not in token:
+        integer, fractional = token.split(",", maxsplit=1)
+        token = (
+            f"{integer}.{fractional}"
+            if len(fractional) <= 2
+            else token.replace(",", "")
+        )
+    else:
+        token = token.replace(",", "")
+    try:
+        return float(token)
+    except ValueError:
+        return None
+
+
+def parse_boolean(text: str) -> bool | None:
+    tokens = set(normalize_answer(text).split())
+    positive = bool(tokens & {"yes", "true", "correct"})
+    negative = bool(tokens & {"no", "false", "incorrect"})
+    if positive == negative:
+        return None
+    return positive
+
+
+def levenshtein_distance(left: str, right: str) -> int:
+    if len(left) < len(right):
+        return levenshtein_distance(right, left)
+    if not right:
+        return len(left)
+
+    previous_row = list(range(len(right) + 1))
+    for left_index, left_char in enumerate(left):
+        current_row = [left_index + 1]
+        for right_index, right_char in enumerate(right):
+            substitution_cost = 0 if left_char == right_char else 1
+            current_row.append(
+                min(
+                    current_row[right_index] + 1,
+                    previous_row[right_index + 1] + 1,
+                    previous_row[right_index] + substitution_cost,
+                )
+            )
+        previous_row = current_row
+    return previous_row[-1]
+
+
+def normalized_levenshtein_similarity(prediction: str, gold: str) -> float:
+    prediction = prediction.strip().lower()
+    gold = gold.strip().lower()
+    if not prediction and not gold:
+        return 1.0
+    if not prediction or not gold:
+        return 0.0
+    distance = levenshtein_distance(prediction, gold)
+    return 1.0 - distance / max(len(prediction), len(gold))
+
+
+def anls_score(prediction: str, gold: str, threshold: float = 0.5) -> float:
+    similarity = normalized_levenshtein_similarity(prediction, gold)
+    return similarity if similarity >= threshold else 0.0
+
+
+def accuracy_score(prediction: str, gold: str, answer_type: str) -> float:
+    prediction_norm = normalize_answer(prediction)
+    gold_norm = normalize_answer(gold)
+
+    if answer_type == "unanswerable":
+        phrases = (
+            "not answerable",
+            "unanswerable",
+            "cannot be determined",
+            "cannot be answered",
+            "not enough information",
+        )
+        return 1.0 if any(phrase in prediction_norm for phrase in phrases) else 0.0
+
+    if answer_type == "boolean":
+        prediction_bool = parse_boolean(prediction)
+        gold_bool = parse_boolean(gold)
+        return (
+            1.0 if prediction_bool is not None and prediction_bool == gold_bool else 0.0
+        )
+
+    if answer_type in {"numeric", "percentage"}:
+        prediction_number = extract_number(prediction)
+        gold_number = extract_number(gold)
+        if prediction_number is None or gold_number is None:
+            return 0.0
+        if gold_number == 0:
+            return 1.0 if abs(prediction_number) < 1e-6 else 0.0
+        relative_error = abs(prediction_number - gold_number) / abs(gold_number)
+        return 1.0 if relative_error <= 0.05 else 0.0
+
+    if answer_type == "single_choice":
+        prediction_option = re.search(r"\b([A-D])\b", prediction.strip().upper())
+        gold_option = re.search(r"\b([A-D])\b", gold.strip().upper())
+        return (
+            1.0
+            if prediction_option
+            and gold_option
+            and prediction_option.group(1) == gold_option.group(1)
+            else 0.0
+        )
+
+    if gold_norm and gold_norm in prediction_norm:
+        return 1.0
+    if normalized_levenshtein_similarity(prediction_norm, gold_norm) >= 0.8:
+        return 1.0
+    return 0.0
+
+
+def token_f1_score(prediction: str, gold: str) -> float:
+    prediction_tokens = set(normalize_answer(prediction).split())
+    gold_tokens = set(normalize_answer(gold).split())
+    if not gold_tokens:
+        return 1.0 if not prediction_tokens else 0.0
+    if not prediction_tokens:
+        return 0.0
+    overlap = prediction_tokens & gold_tokens
+    if not overlap:
+        return 0.0
+    precision = len(overlap) / len(prediction_tokens)
+    recall = len(overlap) / len(gold_tokens)
+    return 2 * precision * recall / (precision + recall)
+
+
+def add_breakdown(
+    breakdowns: dict[str, dict[str, MetricBucket]],
+    name: str,
+    key: Any,
+    accuracy: float,
+    token_f1: float,
+    anls: float,
+) -> None:
+    label = string_value(key) or "unknown"
+    breakdowns[name][label].add(accuracy, token_f1, anls)
+
+
+def evaluate(
+    gold_records: dict[str, dict[str, Any]],
+    predictions: dict[str, str],
+    statuses: dict[str, str],
+    ignore_missing: bool = False,
+) -> dict[str, Any]:
+    overall = MetricBucket()
+    breakdowns: dict[str, dict[str, MetricBucket]] = {
+        "split": defaultdict(MetricBucket),
+        "domain": defaultdict(MetricBucket),
+        "reasoning_type": defaultdict(MetricBucket),
+        "answer_format": defaultdict(MetricBucket),
+        "difficulty": defaultdict(MetricBucket),
+        "doc_type": defaultdict(MetricBucket),
+        "evidence_source": defaultdict(MetricBucket),
+    }
+    per_question: list[dict[str, Any]] = []
+    missing_count = 0
+
+    for question_id, row in gold_records.items():
+        if question_id not in predictions:
+            missing_count += 1
+            if ignore_missing:
+                continue
+        prediction = predictions.get(question_id, "")
+        status = statuses.get(question_id, "missing")
+
+        gold = gold_answer(row)
+        answer_type = answer_format(row)
+        normalized_status = (
+            status.strip().casefold().replace("-", "_").replace(" ", "_")
+        )
+        if normalized_status in SUCCESS_STATUSES:
+            accuracy = accuracy_score(prediction, gold, answer_type)
+            token_f1 = token_f1_score(prediction, gold)
+            anls = anls_score(prediction, gold)
+        else:
+            accuracy = 0.0
+            token_f1 = 0.0
+            anls = 0.0
+        overall.add(accuracy, token_f1, anls)
+
+        row_metadata = metadata(row)
+        split = string_value(row.get("task_type", "unknown"))
+        add_breakdown(breakdowns, "split", split, accuracy, token_f1, anls)
+        add_breakdown(
+            breakdowns, "domain", row_metadata.get("domain"), accuracy, token_f1, anls
+        )
+        add_breakdown(
+            breakdowns,
+            "reasoning_type",
+            row_metadata.get("reasoning_type"),
+            accuracy,
+            token_f1,
+            anls,
+        )
+        add_breakdown(
+            breakdowns,
+            "answer_format",
+            answer_payload(row).get("format"),
+            accuracy,
+            token_f1,
+            anls,
+        )
+        add_breakdown(
+            breakdowns,
+            "difficulty",
+            row_metadata.get("difficulty"),
+            accuracy,
+            token_f1,
+            anls,
+        )
+        add_breakdown(
+            breakdowns,
+            "doc_type",
+            row_metadata.get("doc_type"),
+            accuracy,
+            token_f1,
+            anls,
+        )
+
+        evidence_sources = row_metadata.get("evidence_sources") or ["unknown"]
+        if not isinstance(evidence_sources, list):
+            evidence_sources = [evidence_sources]
+        for evidence_source in evidence_sources:
+            add_breakdown(
+                breakdowns, "evidence_source", evidence_source, accuracy, token_f1, anls
+            )
+
+        per_question.append(
+            {
+                "question_id": question_id,
+                "prediction": prediction,
+                "gold_answer": gold,
+                "answer_format": answer_payload(row).get("format", "Str"),
+                "status": status,
+                "accuracy": round(accuracy, 6),
+                "token_f1": round(token_f1, 6),
+                "anls": round(anls, 6),
+                "split": split,
+                "domain": row_metadata.get("domain", "unknown"),
+                "reasoning_type": row_metadata.get("reasoning_type", "unknown"),
+            }
+        )
+
+    extra_prediction_count = len(set(predictions) - set(gold_records))
+    return {
+        "gold_count": len(gold_records),
+        "prediction_count": len(predictions),
+        "evaluated_count": overall.summary()["count"],
+        "missing_prediction_count": missing_count,
+        "extra_prediction_count": extra_prediction_count,
+        "overall": overall.summary(),
+        "breakdowns": {
+            name: {key: bucket.summary() for key, bucket in sorted(group.items())}
+            for name, group in breakdowns.items()
+        },
+        "per_question": per_question,
+    }
+
+
+def write_per_question_csv(rows: list[dict[str, Any]], output_path: Path) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    fieldnames = [
+        "question_id",
+        "prediction",
+        "gold_answer",
+        "answer_format",
+        "status",
+        "accuracy",
+        "token_f1",
+        "anls",
+        "split",
+        "domain",
+        "reasoning_type",
+    ]
+    with output_path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def default_data_dir() -> Path:
+    script_dir = Path(__file__).resolve().parent
+    for data_dir in (script_dir / "data", script_dir.parent / "data"):
+        if data_dir.exists():
+            return data_dir
+    return script_dir.parent / "data"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Evaluate XL-DocBench predictions")
+    parser.add_argument(
+        "--predictions", required=True, type=Path, help="Prediction JSON/JSONL file"
+    )
+    parser.add_argument(
+        "--data-dir",
+        type=Path,
+        default=default_data_dir(),
+        help="Directory containing QA JSONL files",
+    )
+    parser.add_argument(
+        "--gold-files",
+        nargs="+",
+        type=Path,
+        default=None,
+        help="Gold QA JSONL files; defaults to qa_single_doc and qa_cross_doc",
+    )
+    parser.add_argument(
+        "--prediction-field", default="", help="Optional explicit prediction field name"
+    )
+    parser.add_argument(
+        "--ignore-missing",
+        action="store_true",
+        help="Evaluate only questions present in the prediction file",
+    )
+    parser.add_argument(
+        "--output", type=Path, default=None, help="Write JSON report to this path"
+    )
+    parser.add_argument(
+        "--per-question-csv",
+        type=Path,
+        default=None,
+        help="Optional per-question CSV output",
+    )
+    parser.add_argument(
+        "--no-per-question-json",
+        action="store_true",
+        help="Omit per-question rows from the JSON report",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    gold_files = args.gold_files
+    if gold_files is None:
+        gold_files = [
+            args.data_dir / "qa_single_doc.jsonl",
+            args.data_dir / "qa_cross_doc.jsonl",
+        ]
+
+    missing_gold_files = [str(path) for path in gold_files if not path.exists()]
+    if missing_gold_files:
+        raise FileNotFoundError(f"Gold file(s) not found: {missing_gold_files}")
+
+    gold_records = load_gold_records(gold_files)
+    predictions, statuses = load_predictions(args.predictions, args.prediction_field)
+    report = evaluate(
+        gold_records, predictions, statuses, ignore_missing=args.ignore_missing
+    )
+
+    if args.per_question_csv:
+        write_per_question_csv(report["per_question"], args.per_question_csv)
+    if args.no_per_question_json:
+        report = {key: value for key, value in report.items() if key != "per_question"}
+
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(
+            json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8"
+        )
+
+    overall = report["overall"]
+    print("XL-DocBench evaluation")
+    print(f"  gold questions:       {report['gold_count']}")
+    print(f"  predictions:          {report['prediction_count']}")
+    print(f"  evaluated:            {report['evaluated_count']}")
+    print(f"  missing predictions:  {report['missing_prediction_count']}")
+    print(f"  extra predictions:    {report['extra_prediction_count']}")
+    print(f"  Accuracy:             {overall['accuracy'] * 100:.2f}")
+    print(f"  Token F1:             {overall['token_f1'] * 100:.2f}")
+    print(f"  ANLS:                 {overall['anls'] * 100:.2f}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, TypeError, ValueError) as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        sys.exit(1)

code/examples/gold_sample.jsonl

@@ -0,0 +1,5 @@
+{"question_id":"adubench_single_000001","question":"In the two executive summaries, which Chapter 1 phrase links pollution to human health more directly than Chapter 2’s climate-change wording?","answer":{"format":"Str","value":"the biggest single risk to human health worldwide","verification_rule":"casefold_exact_match"},"metadata":{"domain":"scientific_academic","reasoning_type":"comparison","difficulty":"hard","doc_type":"report"},"task_type":"single_doc"}
+{"question_id":"adubench_single_000002","question":"Using Chapter 1's 'more than half' of 17 SDGs and Chapter 4's 12 GEO-6 entry-point issues, by how many percentage points does the minimum required issue share exceed 50%?","answer":{"format":"Int","value":"25","verification_rule":"numeric_tolerance"},"metadata":{"domain":"scientific_academic","reasoning_type":"compliance","difficulty":"very_hard","doc_type":"report"},"task_type":"single_doc"}
+{"question_id":"adubench_single_000083","question":"По оглавлению, какой вводный раздел расположен ближе к «СОДЕРЖАНИЮ» по числу страниц — «ГЛАВНОЕ» или «ПРЕДИСЛОВИЕ» — и совпадает ли названная в обоих разделах программная рамка действий с «Повесткой-2030»","answer":{"format":"Str","value":"B","verification_rule":"choice_exact_match"},"metadata":{"domain":"scientific_academic","reasoning_type":"comparison","difficulty":"very_hard","doc_type":"report"},"task_type":"single_doc","options":["«ГЛАВНОЕ»; «Стратегическая рамочная программа ФАО на 2022–2031 годы»","«ГЛАВНОЕ»; «Повестка дня в области устойчивого развития на период до 2030 года»","«ПРЕДИСЛОВИЕ»; «Стратегия ФАО в области науки и инноваций»","«ПРЕДИСЛОВИЕ»; «Повестка дня в области устойчивого развития на период до 2030 года»"]}
+{"question_id":"adubench_single_000193","question":"Across the sections titled \"Introduction\" and \"The year under review,\" what exact inflation target is named in the document’s discussion of inflation moving toward targets and then remaining above central bank targets?","answer":{"format":"None","value":"Not answerable","verification_rule":"exact_match"},"metadata":{"domain":"finance_business","reasoning_type":"compliance","difficulty":"medium","doc_type":"report"},"task_type":"single_doc"}
+{"question_id":"adubench_cross_000001","question":"Which instrument category is named in both the French global measures discussion and the English framework-design discussion as a key tool?","answer":{"format":"Str","value":"macroprudential measures","verification_rule":"casefold_exact_match"},"metadata":{"domain":"finance_business","reasoning_type":"reference_chain","difficulty":"very_hard","doc_type":"cross_document_series"},"task_type":"cross_doc"}

code/examples/load_data.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""Load XL-DocBench JSONL files with the Python standard library."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--release-root",
+        type=Path,
+        default=Path(__file__).resolve().parents[2],
+        help="Release directory; defaults to the directory containing code/",
+    )
+    return parser.parse_args()
+
+
+def read_jsonl(path: Path) -> list[dict]:
+    with path.open("r", encoding="utf-8") as handle:
+        return [json.loads(line) for line in handle if line.strip()]
+
+
+def main() -> None:
+    root = parse_args().release_root.resolve()
+    documents = read_jsonl(root / "data/documents.jsonl")
+    single_doc = read_jsonl(root / "data/qa_single_doc.jsonl")
+    cross_doc = read_jsonl(root / "data/qa_cross_doc.jsonl")
+
+    print(f"documents:  {len(documents):,}")
+    print(f"single_doc: {len(single_doc):,}")
+    print(f"cross_doc:  {len(cross_doc):,}")
+    print(f"first question: {single_doc[0]['question']}")
+
+
+if __name__ == "__main__":
+    main()

code/examples/predictions_sample.jsonl

@@ -0,0 +1,5 @@
+{"question_id":"adubench_single_000001","prediction":"the biggest single risk to human health worldwide"}
+{"question_id":"adubench_single_000002","prediction":"25"}
+{"question_id":"adubench_single_000083","prediction":"B"}
+{"question_id":"adubench_single_000193","prediction":"Not answerable"}
+{"question_id":"adubench_cross_000001","prediction":"macroprudential measures"}

code/quickstart.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""Run a zero-dependency XL-DocBench release smoke test."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+sys.dont_write_bytecode = True
+
+import evaluate as evaluator
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--release-root",
+        type=Path,
+        default=Path(__file__).resolve().parent.parent,
+        help="Release directory; defaults to the parent of code/",
+    )
+    return parser.parse_args()
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            if not line.strip():
+                continue
+            value = json.loads(line)
+            require(isinstance(value, dict), f"Expected object on {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def row_documents(row: dict[str, Any]) -> list[dict[str, Any]]:
+    if row.get("task_type") == "single_doc":
+        document = row.get("document")
+        require(
+            isinstance(document, dict), f"Missing document in {row.get('question_id')}"
+        )
+        return [document]
+    documents = row.get("documents")
+    require(
+        isinstance(documents, list), f"Missing documents in {row.get('question_id')}"
+    )
+    return documents
+
+
+def validate_release(release_root: Path) -> dict[str, int]:
+    manifest_path = release_root / "manifest.json"
+    require(manifest_path.is_file(), f"Missing {manifest_path}")
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+    release_files = manifest.get("release_files", {})
+    paths = {
+        name: release_root / release_files[name]
+        for name in ("documents", "single_doc_questions", "cross_doc_questions")
+    }
+    for path in paths.values():
+        require(path.is_file(), f"Missing release file: {path}")
+
+    documents = read_jsonl(paths["documents"])
+    single = read_jsonl(paths["single_doc_questions"])
+    cross = read_jsonl(paths["cross_doc_questions"])
+    questions = single + cross
+
+    require(len(documents) == manifest["document_count"], "Document count mismatch")
+    require(len(single) == manifest["single_doc_qa_count"], "Single-doc count mismatch")
+    require(len(cross) == manifest["cross_doc_qa_count"], "Cross-doc count mismatch")
+    require(len(questions) == manifest["qa_count"], "QA count mismatch")
+
+    document_ids = [str(document.get("document_id") or "") for document in documents]
+    question_ids = [str(row.get("question_id") or "") for row in questions]
+    require(all(document_ids), "Empty document_id")
+    require(all(question_ids), "Empty question_id")
+    require(len(set(document_ids)) == len(document_ids), "Duplicate document_id")
+    require(len(set(question_ids)) == len(question_ids), "Duplicate question_id")
+
+    known_documents = set(document_ids)
+    referenced_documents: set[str] = set()
+    evidence_item_count = 0
+    for row in questions:
+        question_id = row["question_id"]
+        require(
+            str(row.get("question") or "").strip(), f"Empty question: {question_id}"
+        )
+        require(isinstance(row.get("answer"), dict), f"Missing answer: {question_id}")
+        documents_for_row = row_documents(row)
+        metadata = row.get("metadata")
+        require(isinstance(metadata, dict), f"Missing metadata: {question_id}")
+        require(
+            metadata.get("n_context_documents") == len(documents_for_row),
+            f"Context-document count mismatch: {question_id}",
+        )
+
+        actual_evidence_documents = 0
+        for document in documents_for_row:
+            document_id = str(document.get("document_id") or "")
+            require(document_id in known_documents, f"Unknown document: {document_id}")
+            referenced_documents.add(document_id)
+            require(
+                document.get("evidence_page_numbering") == "pdf_index",
+                f"Missing evidence page semantics: {question_id}",
+            )
+            evidence_pages = document.get("evidence_pages")
+            evidence_items = document.get("evidence_items")
+            require(
+                isinstance(evidence_pages, list),
+                f"Invalid evidence_pages: {question_id}",
+            )
+            require(
+                isinstance(evidence_items, list),
+                f"Invalid evidence_items: {question_id}",
+            )
+            actual_evidence_documents += bool(evidence_pages or evidence_items)
+            evidence_item_count += len(evidence_items)
+            for item in evidence_items:
+                require(
+                    str(item.get("locator") or "").strip(),
+                    f"Empty locator: {question_id}",
+                )
+                require(bool(item.get("pages")), f"Empty item pages: {question_id}")
+                require(
+                    item.get("page_numbering") == "annotator_supplied",
+                    f"Missing item page semantics: {question_id}",
+                )
+                require(
+                    item.get("evidence_kind")
+                    in {"supporting_excerpt", "annotator_rationale"},
+                    f"Invalid evidence kind: {question_id}",
+                )
+
+        require(
+            metadata.get("n_evidence_documents") == actual_evidence_documents,
+            f"Evidence-document count mismatch: {question_id}",
+        )
+        for item in row.get("unassigned_evidence_items", []):
+            require(
+                item.get("evidence_kind") == "unassigned_annotation",
+                f"Invalid unassigned evidence kind: {question_id}",
+            )
+
+    require(referenced_documents == known_documents, "Unreferenced released documents")
+    require(
+        evidence_item_count == manifest["evidence_item_count"],
+        "Evidence-item count mismatch",
+    )
+
+    score_path = release_root / release_files["per_question_scores"]
+    summary_path = release_root / release_files["score_summary"]
+    require(score_path.is_file(), f"Missing score file: {score_path}")
+    require(summary_path.is_file(), f"Missing score summary: {summary_path}")
+    score_rows = read_jsonl(score_path)
+    score_ids = [str(row.get("question_id") or "") for row in score_rows]
+    require(len(score_rows) == len(questions), "Per-question score count mismatch")
+    require(set(score_ids) == set(question_ids), "Per-question score IDs mismatch")
+    score_summary = json.loads(summary_path.read_text(encoding="utf-8"))
+    systems = score_summary.get("systems", {})
+    require(
+        len(systems) == manifest["scored_system_count"], "Scored-system count mismatch"
+    )
+    expected_systems = set(systems)
+    for row in score_rows:
+        row_scores = row.get("scores")
+        require(isinstance(row_scores, dict), "Invalid per-question scores")
+        require(set(row_scores) == expected_systems, "Per-question system mismatch")
+        for metrics in row_scores.values():
+            require(isinstance(metrics, dict), "Invalid metric record")
+            for metric in ("accuracy", "token_f1", "anls"):
+                value = metrics.get(metric)
+                require(
+                    isinstance(value, (int, float)) and 0 <= value <= 1,
+                    f"Invalid {metric} score",
+                )
+    return {
+        "documents": len(documents),
+        "single_doc": len(single),
+        "cross_doc": len(cross),
+        "questions": len(questions),
+        "evidence_items": evidence_item_count,
+        "systems": len(systems),
+    }
+
+
+def evaluate_examples(code_dir: Path) -> dict[str, float | int]:
+    examples = code_dir / "examples"
+    gold = evaluator.load_gold_records([examples / "gold_sample.jsonl"])
+    predictions, statuses = evaluator.load_predictions(
+        examples / "predictions_sample.jsonl"
+    )
+    report = evaluator.evaluate(gold, predictions, statuses)
+    overall = report["overall"]
+    require(report["evaluated_count"] == 5, "Example evaluation count mismatch")
+    require(overall["accuracy"] == 1.0, "Example Accuracy regression")
+    require(overall["token_f1"] == 1.0, "Example Token F1 regression")
+    require(overall["anls"] == 1.0, "Example ANLS regression")
+    return overall
+
+
+def main() -> None:
+    args = parse_args()
+    release_root = args.release_root.resolve()
+    counts = validate_release(release_root)
+    metrics = evaluate_examples(Path(__file__).resolve().parent)
+
+    print("XL-DocBench smoke test: PASS")
+    print(
+        f"  data: {counts['documents']:,} documents, "
+        f"{counts['questions']:,} QA "
+        f"({counts['single_doc']:,} single + {counts['cross_doc']:,} cross)"
+    )
+    print(f"  evidence items: {counts['evidence_items']:,}")
+    print(f"  per-question scores: {counts['systems']} systems")
+    print(
+        f"  sample metrics: Accuracy={metrics['accuracy'] * 100:.1f}, "
+        f"F1={metrics['token_f1'] * 100:.1f}, ANLS={metrics['anls'] * 100:.1f}"
+    )
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (KeyError, OSError, TypeError, ValueError, json.JSONDecodeError) as exc:
+        print(f"XL-DocBench smoke test: FAIL — {exc}", file=sys.stderr)
+        sys.exit(1)

manifest.json

@@ -0,0 +1,79 @@
+{
+  "annotation_not_answerable_non_none_count": 1,
+  "answer_format_counts": {
+    "Float": 110,
+    "Int": 209,
+    "None": 188,
+    "Str": 838
+  },
+  "cross_doc_context_document_count_distribution": {
+    "10": 19,
+    "12": 4,
+    "2": 4,
+    "3": 14,
+    "4": 17,
+    "5": 8,
+    "6": 20,
+    "7": 19,
+    "8": 47,
+    "9": 2
+  },
+  "cross_doc_evidence_document_count_distribution": {
+    "0": 18,
+    "2": 79,
+    "3": 45,
+    "4": 12
+  },
+  "cross_doc_qa_count": 154,
+  "document_count": 292,
+  "domain_counts": {
+    "finance_business": 329,
+    "legal_regulation": 275,
+    "medical_clinical": 233,
+    "narrative_literature": 81,
+    "scientific_academic": 189,
+    "technical_engineering": 238
+  },
+  "empty_evidence_qa_count": 189,
+  "evidence_item_count": 3044,
+  "page_indexing": "Document evidence_pages use one-based PDF/release page indices. Evidence-item pages preserve annotator-supplied page references and use page_numbering=annotator_supplied; printed page labels can differ from PDF indices. Items marked annotator_rationale are review explanations rather than verbatim document excerpts. Row-level items marked unassigned_annotation are retained provenance that is not counted as released evidence. Rows released without supporting evidence have empty evidence arrays and n_evidence_documents=0.",
+  "qa_count": 1345,
+  "reasoning_type_counts": {
+    "aggregation": 44,
+    "comparison": 200,
+    "compliance": 59,
+    "consistency": 19,
+    "counterfactual": 56,
+    "coverage": 163,
+    "ranking": 156,
+    "reconciliation": 107,
+    "reference_chain": 206,
+    "set_difference": 101,
+    "temporal": 50,
+    "unanswerable": 184
+  },
+  "release_files": {
+    "cross_doc_questions": "data/qa_cross_doc.jsonl",
+    "documents": "data/documents.jsonl",
+    "per_question_scores": "results/scores.jsonl",
+    "score_summary": "results/summary.json",
+    "single_doc_questions": "data/qa_single_doc.jsonl"
+  },
+  "release_version": "xldocbench_strict_1345_v1",
+  "score_evaluator_sha256": "efc56cb25ba136e09ceaccb5d8006ea9461f71a68998f2987073387682a5e547",
+  "scored_system_count": 13,
+  "single_doc_qa_count": 1191,
+  "unanswerable_qa_count": 188,
+  "unassigned_evidence_item_count": 11,
+  "url_mapping_coverage": "292/292",
+  "variant_info": {
+    "variant": "strict_excluding_rag_not_approved",
+    "source_git_revision": "dd2aa7fcc241c6fe0b2e5b315c220460e0f2ab94",
+    "match_method": "exact_source_url",
+    "filter_rule": "Remove documents with RAG / Not Approved status and every QA row that references one of those documents, then prune documents left with no QA references.",
+    "rag_restricted_document_count": 37,
+    "orphaned_document_count": 2,
+    "removed_document_count": 39,
+    "removed_qa_count": 174
+  }
+}

results/summary.json

@@ -0,0 +1,101 @@
+{
+  "dataset_variant": "strict_excluding_rag_not_approved",
+  "question_count": 1345,
+  "evaluator": "code/evaluate.py",
+  "evaluator_sha256": "efc56cb25ba136e09ceaccb5d8006ea9461f71a68998f2987073387682a5e547",
+  "score_scale": "0_to_1",
+  "systems": {
+    "gpt_5_2_img": {
+      "name": "GPT-5.2",
+      "input": "img",
+      "accuracy": 0.2171,
+      "token_f1": 0.249504,
+      "anls": 0.219197
+    },
+    "gpt_5_2_ocr": {
+      "name": "GPT-5.2",
+      "input": "ocr",
+      "accuracy": 0.311524,
+      "token_f1": 0.336904,
+      "anls": 0.285114
+    },
+    "gpt_5_4_img": {
+      "name": "GPT-5.4",
+      "input": "img",
+      "accuracy": 0.267658,
+      "token_f1": 0.297605,
+      "anls": 0.263317
+    },
+    "gpt_5_4_ocr": {
+      "name": "GPT-5.4",
+      "input": "ocr",
+      "accuracy": 0.383643,
+      "token_f1": 0.397047,
+      "anls": 0.341731
+    },
+    "kimi_k2_5_img": {
+      "name": "Kimi-K2.5",
+      "input": "img",
+      "accuracy": 0.260223,
+      "token_f1": 0.275877,
+      "anls": 0.230395
+    },
+    "kimi_k2_5_ocr": {
+      "name": "Kimi-K2.5",
+      "input": "ocr",
+      "accuracy": 0.360595,
+      "token_f1": 0.382426,
+      "anls": 0.326386
+    },
+    "deepseek_v3_2_ocr": {
+      "name": "DeepSeek-V3.2",
+      "input": "ocr",
+      "accuracy": 0.296654,
+      "token_f1": 0.329908,
+      "anls": 0.289058
+    },
+    "qwen3_5_4b_img": {
+      "name": "Qwen3.5-4B",
+      "input": "img",
+      "accuracy": 0.205204,
+      "token_f1": 0.208648,
+      "anls": 0.182636
+    },
+    "qwen3_5_4b_ocr": {
+      "name": "Qwen3.5-4B",
+      "input": "ocr",
+      "accuracy": 0.289963,
+      "token_f1": 0.32228,
+      "anls": 0.28128
+    },
+    "qwen3_5_9b_img": {
+      "name": "Qwen3.5-9B",
+      "input": "img",
+      "accuracy": 0.20223,
+      "token_f1": 0.226944,
+      "anls": 0.20179
+    },
+    "simpledoc_gpt_5_4": {
+      "name": "SimpleDoc + GPT-5.4",
+      "input": "agent",
+      "accuracy": 0.362082,
+      "token_f1": 0.336157,
+      "anls": 0.242958
+    },
+    "mdocagent_gpt_5_4": {
+      "name": "MDocAgent + GPT-5.4",
+      "input": "agent",
+      "accuracy": 0.318216,
+      "token_f1": 0.305814,
+      "anls": 0.226412
+    },
+    "deepread_gpt_5_4": {
+      "name": "DeepRead + GPT-5.4",
+      "input": "agent",
+      "accuracy": 0.277323,
+      "token_f1": 0.269935,
+      "anls": 0.211733
+    }
+  },
+  "scores_sha256": "d3db5e13eaa19ce1cd6776eb5ed8dc243dcc166109884f21d668bfe86c3de39a"
+}

schema/release_format_sample.json

@@ -0,0 +1,273 @@
+{
+  "variant": "strict_excluding_rag_not_approved",
+  "evidence_semantics": "Document evidence_pages use one-based PDF/release page indices. Evidence-item pages preserve annotator-supplied page references and use page_numbering=annotator_supplied; printed page labels can differ from PDF indices. Items marked annotator_rationale are review explanations rather than verbatim document excerpts. Row-level items marked unassigned_annotation are retained provenance that is not counted as released evidence. Rows released without supporting evidence have empty evidence arrays and n_evidence_documents=0.",
+  "document_manifest_sample": {
+    "avg_chars_per_page": 2690.8,
+    "doc_type": "report",
+    "document_id": "doc_000001",
+    "domain": "finance_business",
+    "file_size_bytes": 4609256,
+    "image_page_ratio": 0.0,
+    "page_count": 204,
+    "pdf_type": "native_digital",
+    "public_metadata": {
+      "authors": [
+        "Ashley Alder"
+      ],
+      "company": "Financial Conduct Authority",
+      "content_year": 2023,
+      "content_year_range": "2022-2023",
+      "governing_body": "UK Parliament (House of Commons)",
+      "language": "English",
+      "organization": "Financial Conduct Authority",
+      "report_period": "FY2022/23 (year ended 31 March 2023)",
+      "sector": "Financial regulation",
+      "ticker": null
+    },
+    "source_host": "www.fca.org.uk",
+    "text_page_ratio": 0.95,
+    "title": "Annual Report and Accounts 2022/23",
+    "url": "https://www.fca.org.uk/publication/annual-reports/annual-report-2022-23.pdf"
+  },
+  "qa_single_doc_sample": {
+    "answer": {
+      "format": "Str",
+      "value": "the biggest single risk to human health worldwide",
+      "verification_rule": "casefold_exact_match"
+    },
+    "document": {
+      "document_id": "doc_000002",
+      "evidence_items": [
+        {
+          "locator": "Page 37",
+          "mentioned_elements": [],
+          "pages": [
+            37
+          ],
+          "quote": "Human activities are causing increasing amounts of pollution, to the extent that this is now recognised as the biggest single risk to human health worldwide",
+          "source_type": "Text",
+          "evidence_kind": "supporting_excerpt",
+          "page_numbering": "annotator_supplied"
+        },
+        {
+          "locator": "Page 38",
+          "mentioned_elements": [],
+          "pages": [
+            38
+          ],
+          "quote": "It emphasizes that a healthy planet is a necessary foundation for human physical, psychological, social, economic and emotional health and well-being",
+          "source_type": "Text",
+          "evidence_kind": "supporting_excerpt",
+          "page_numbering": "annotator_supplied"
+        },
+        {
+          "locator": "Page 40",
+          "mentioned_elements": [],
+          "pages": [
+            40
+          ],
+          "quote": "Throughout GEO-6, evidence is presented of how fundamentally nature’s contributions to people underpin human health and well-being.",
+          "source_type": "Text",
+          "evidence_kind": "supporting_excerpt",
+          "page_numbering": "annotator_supplied"
+        },
+        {
+          "locator": "Page 55",
+          "mentioned_elements": [],
+          "pages": [
+            55
+          ],
+          "quote": "Climate change poses risks to human societies through impacts on food, and water security (established but incomplete), and on human security, health, livelihoods and infrastructure.",
+          "source_type": "Text",
+          "evidence_kind": "supporting_excerpt",
+          "page_numbering": "annotator_supplied"
+        },
+        {
+          "locator": "Page 57",
+          "mentioned_elements": [],
+          "pages": [
+            57
+          ],
+          "quote": "Likewise, climate change has been added as a fifth driver",
+          "source_type": "Text",
+          "evidence_kind": "supporting_excerpt",
+          "page_numbering": "annotator_supplied"
+        },
+        {
+          "locator": "Page 57",
+          "mentioned_elements": [],
+          "pages": [
+            57
+          ],
+          "quote": "In the absence of an adequate response, a changing climate could lead to a pre-modern world of famine, plague, war, and premature death.",
+          "source_type": "Text",
+          "evidence_kind": "supporting_excerpt",
+          "page_numbering": "annotator_supplied"
+        }
+      ],
+      "evidence_pages": [
+        37,
+        38,
+        39,
+        40,
+        42,
+        43,
+        44,
+        45,
+        55,
+        56,
+        57,
+        58,
+        65,
+        66,
+        67,
+        68,
+        72,
+        73,
+        74,
+        75
+      ],
+      "url": "https://digitallibrary.un.org/nanna/record/4008190/files/GEO6_2019.pdf?registerDownload=1&version=1&withMetadata=0&withWatermark=0",
+      "evidence_page_numbering": "pdf_index"
+    },
+    "metadata": {
+      "difficulty": "hard",
+      "doc_type": "report",
+      "doc_type_coarse": "Technical document",
+      "domain": "scientific_academic",
+      "evidence_annotation_status": "has_evidence",
+      "evidence_sources": [
+        "Text"
+      ],
+      "is_unanswerable": false,
+      "n_context_documents": 1,
+      "n_evidence_documents": 1,
+      "reasoning_type": "comparison",
+      "n_candidate_evidence_documents": 1,
+      "candidate_evidence_sources": [
+        "Text"
+      ],
+      "answerability_conflict": false
+    },
+    "question": "In the two executive summaries, which Chapter 1 phrase links pollution to human health more directly than Chapter 2’s climate-change wording?",
+    "question_id": "adubench_single_000001",
+    "task_type": "single_doc"
+  },
+  "qa_cross_doc_sample": {
+    "answer": {
+      "format": "Str",
+      "value": "macroprudential measures",
+      "verification_rule": "casefold_exact_match"
+    },
+    "documents": [
+      {
+        "document_id": "doc_000126",
+        "evidence_items": [
+          {
+            "locator": "Doc1, Page 17",
+            "mentioned_elements": [],
+            "pages": [
+              17
+            ],
+            "quote": "The activation of macroprudential measures is especially important at the current juncture. It can help contain the financial vulnerabilities bequeathed by the unbalanced post-crisis recovery and mitigate the build-up of further risks.",
+            "source_type": "Text",
+            "evidence_kind": "supporting_excerpt",
+            "page_numbering": "annotator_supplied"
+          }
+        ],
+        "evidence_pages": [
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "url": "https://www.bis.org/publ/arpdf/ar2018e.pdf",
+        "evidence_page_numbering": "pdf_index"
+      },
+      {
+        "document_id": "doc_000115",
+        "evidence_items": [],
+        "evidence_pages": [],
+        "url": "https://www.bis.org/publ/arpdf/ar2018_it.pdf",
+        "evidence_page_numbering": "pdf_index"
+      },
+      {
+        "document_id": "doc_000290",
+        "evidence_items": [
+          {
+            "locator": "Doc2, Page 11",
+            "mentioned_elements": [],
+            "pages": [
+              11
+            ],
+            "quote": "Le renforcement de la résilience passe aussi par le déploiement actif de mesures macroprudentielles dans les économies où les déséquilibres financiers se sont accumulés, et, plus généralement, par l'amélioration des dispositifs macroprudentiels.",
+            "source_type": "Text",
+            "evidence_kind": "supporting_excerpt",
+            "page_numbering": "annotator_supplied"
+          }
+        ],
+        "evidence_pages": [
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15
+        ],
+        "url": "https://www.bis.org/publ/arpdf/ar2018_fr.pdf",
+        "evidence_page_numbering": "pdf_index"
+      },
+      {
+        "document_id": "doc_000323",
+        "evidence_items": [],
+        "evidence_pages": [],
+        "url": "https://www.bis.org/publ/arpdf/ar2018_es.pdf",
+        "evidence_page_numbering": "pdf_index"
+      },
+      {
+        "document_id": "doc_000136",
+        "evidence_items": [],
+        "evidence_pages": [],
+        "url": "https://www.bis.org/publ/arpdf/ar2023e.pdf",
+        "evidence_page_numbering": "pdf_index"
+      },
+      {
+        "document_id": "doc_000101",
+        "evidence_items": [],
+        "evidence_pages": [],
+        "url": "https://www.bis.org/publ/arpdf/ar2024e.pdf",
+        "evidence_page_numbering": "pdf_index"
+      }
+    ],
+    "metadata": {
+      "difficulty": "very_hard",
+      "doc_type": "cross_document_series",
+      "doc_type_coarse": "Cross-document series",
+      "domain": "finance_business",
+      "evidence_annotation_status": "has_evidence",
+      "evidence_sources": [
+        "Text"
+      ],
+      "is_unanswerable": false,
+      "n_context_documents": 6,
+      "n_evidence_documents": 2,
+      "reasoning_type": "reference_chain",
+      "n_candidate_evidence_documents": 2,
+      "candidate_evidence_sources": [
+        "Text"
+      ],
+      "answerability_conflict": false
+    },
+    "question": "Which instrument category is named in both the French global measures discussion and the English framework-design discussion as a key tool?",
+    "question_id": "adubench_cross_000001",
+    "task_type": "cross_doc"
+  }
+}