Publish KLAR reproducibility bundle (v1): text-free score bundles + analysis code for the 'Alles klar?' KlarText paper

.gitattributes

@@ -1,60 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.jsonl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,8 @@
+.venv/
+results/
+__pycache__/
+*.pyc
+.pytest_cache/
+data/*
+!data/.gitkeep
+!data/README.md

LICENSE

@@ -0,0 +1,27 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+SPDX-License-Identifier: CC-BY-4.0
+
+Copyright (c) 2026 Fraunhofer IAIS
+
+This work (the analysis code and the text-free per-document score tables in
+`scores/`) is licensed under the Creative Commons Attribution 4.0 International
+License (CC BY 4.0).
+
+You are free to share and adapt this material for any purpose, even
+commercially, provided you give appropriate credit. Appropriate credit means
+citing the accompanying paper (see the "Citation" section of README.md).
+
+Full legal code (the binding terms):
+  https://creativecommons.org/licenses/by/4.0/legalcode
+Human-readable summary:
+  https://creativecommons.org/licenses/by/4.0/
+
+Scope of this license:
+  - Covered: the analysis code and the numeric, text-free score tables in
+    `scores/`.
+  - NOT covered and NOT included: the proprietary scoring engine that produced
+    the scores. It is not distributed here and no license to it is granted.
+  - The score tables are DERIVED from third-party corpora that carry their own
+    licenses. This repository redistributes numeric features only, not those
+    texts. Obtaining or rebuilding the underlying corpora is governed by each
+    corpus's own terms; see docs/DATASETS.md.

README.md

@@ -1,3 +1,93 @@
 ---
 license: cc-by-4.0
+language:
+  - de
+pretty_name: "KLAR - German Simplicity Score (Reproducibility Bundle)"
+tags:
+  - readability
+  - text-simplification
+  - plain-language
+  - leichte-sprache
+  - german
+  - reproducibility
+size_categories:
+  - 1K<n<10K
+viewer: false
 ---
+
+# KLAR - reproducibility bundle
+
+Data and code to reproduce the paper **[Alles klar? A Rule-Based Simplicity Score for German Text Simplification](https://klar-text.github.io/acceptedpapers/)** (KlarText workshop; proceedings link to follow). KLAR is a reference-free, rule-based readability score for German plain language. This repository reproduces every table and number in the paper.
+
+The bundle ships **text-free per-document scores** (numeric features only, no source or simplified text) plus the analysis code that turns them into the paper's results. The scoring engine that produced the numbers is a closed product and is not included: you can re-run the statistics on the released scores, but you cannot regenerate the scores themselves.
+
+Some of the underlying corpora are license-restricted, so their texts are not redistributed here. If you hold a license and want to see the text behind a score, [`docs/DATASETS.md`](docs/DATASETS.md) explains how to rebuild each corpus into `data/`.
+
+## Quickstart
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+
+python -m experiments.rq1_validate --scores scores/deplain_web.jsonl
+python -m experiments.rq2_convergent --scores-dir scores
+python -m experiments.rq3_graded --scores scores/apa_lha.jsonl
+python -m experiments.rq4_competitors
+python -m experiments.rq4_tost
+```
+
+Each script writes its results JSON (and, for RQ2, a scatter figure) to `results/` and prints a report to stdout. See [`docs/REPRODUCE.md`](docs/REPRODUCE.md) for the full command set across all four corpora and the mapping from each script to its research question.
+
+## Layout
+
+- `scores/`: the released text-free per-document score bundles (JSONL), one file per corpus.
+- `experiments/`: the analysis scripts. They read only the scores; the scorer is not included.
+- `data/`: empty. License holders rebuild corpora here (see `docs/DATASETS.md`).
+- `docs/DATASETS.md`: how to obtain and rebuild each corpus.
+- `docs/REPRODUCE.md`: full reproduction walkthrough.
+
+## Dataset structure
+
+Each file in `scores/` is JSONL, one row per document. Every evaluated pair (an original document and its simplified counterpart) contributes **two rows**, linked by `pair_idx` and distinguished by `side` (`orig` / `simp`). Rows carry numbers and opaque metadata only: no source or simplified text is present anywhere in the bundle.
+
+Fields (see `experiments/scores_bundle.py::make_row`, the source of truth):
+
+- `schema`: bundle schema version (currently `1`).
+- `item_id`: `"<dataset>:<pair_idx>:<side>"`, e.g. `"apa_lha:0:orig"`.
+- `dataset`: corpus name (matches the file, e.g. `"apa_lha"`).
+- `pair_idx`: index of the orig/simp pair within the corpus.
+- `side`: `"orig"` or `"simp"`.
+- `sub`: source sub-corpus label (feeds corpus filtering and per-subcorpus stats).
+- `register`: source register label, or `null`.
+- `per_rule`: `{rule_name: {raw, scaled, w}}` for the 20 calibrated readability rules (e.g. `rule_simple_words`, `rule_short_sentences`). `raw` is the unscaled rule score, `scaled` maps it onto a common 0-1 scale, `w` is the rule's calibrated weight.
+- `composite`: `{raw, scaled, scaled_conf}`. `scaled_conf` is the metric reported in the paper.
+- `readability`: `{flesch, lix, wiener_sachtextformel}`, the standard readability formulas computed on the source text, sign-corrected so that higher always means simpler.
+- `n_words`: word count of the (unreleased) source text.
+- `meta`: non-text scalar fields carried through from the source corpus (e.g. `level`, `article_id`); never free text.
+
+Example row (fabricated numbers):
+
+```json
+{
+  "schema": 1,
+  "item_id": "apa_lha:0:orig",
+  "dataset": "apa_lha",
+  "pair_idx": 0,
+  "side": "orig",
+  "sub": "apa_lha_a2",
+  "register": null,
+  "per_rule": {
+    "rule_simple_words": { "raw": 0.71, "scaled": 0.64, "w": 0.61 }
+  },
+  "composite": { "raw": 0.77, "scaled": 0.47, "scaled_conf": 0.38 },
+  "readability": { "flesch": 55.9, "lix": -58.2, "wiener_sachtextformel": -10.0 },
+  "n_words": 288,
+  "meta": { "level": "A2", "article_id": "0_2019" }
+}
+```
+
+`scores/competitors.jsonl` is a second, differently-shaped bundle for the RQ4 competitor comparison: one row per (dataset, item, **system**) instead of per (dataset, item, side). `system` is one of `source` / `human` / `KLAR` or a competitor model (e.g. `German4all`, `erlesen-leo-7b`, `erlesen-leo-13b`, `elgepa-8b`). Fields: `composite.scaled_conf`, `readability.flesch`, `n_words`, `sub`; no per-rule breakdown, no text. Read by `experiments/rq4_competitors.py` and `rq4_tost.py`.
+
+## Citation
+
+TODO: add the BibTeX once the proceedings are out. Until then, cite the paper by title: _Alles klar? A Rule-Based Simplicity Score for German Text Simplification_ (KlarText workshop).

data/README.md

@@ -0,0 +1 @@
+Tier-2 users: rebuild corpora here as `<dataset>.json` per `docs/DATASETS.md` (e.g. `data/deplain_web.json`).

data_process/apa_lha.py

@@ -0,0 +1,108 @@
+"""Build an eval dataset from APA-LHA (Austria Presse Agentur, sentence-aligned).
+
+APA-LHA (Spring/Stodden, the "LHA" sentence-aligned release of the APA news corpus)
+gives each article at the ORIGINAL register plus a CEFR-graded simplification at **two**
+levels - A2 and B1. That graded structure is unique among our corpora: 1344 articles
+exist at BOTH A2 and B1, enabling an ordinal *monotonicity* test (original > B1 > A2),
+not just binary original-vs-simple discrimination.
+
+Layout on disk (the download):
+    <root>/A2-OR/<id>_<year>.de          original (complex)
+    <root>/A2-OR/<id>_<year>_A2.simpde   simplified to A2
+    <root>/B1-OR/<id>_<year>.de          original (complex)
+    <root>/B1-OR/<id>_<year>_B1.simpde   simplified to B1
+
+⚠️ This is a SENTENCE-aligned release: line N of `.de` aligns to line N of `.simpde`,
+and a sentence repeats across rows for m:n alignments. We reconstruct document-level
+text by order-preserving global de-duplication (same as `toborek._dedup_join`). The
+resulting docs are SHORT (simplified median ~39 words A2 / ~54 B1) - well below the
+MW100 evaluation floor for most pairs. Two intended uses, both downstream:
+  * MW100-strict discrimination: `validate_metric --dataset apa_lha --min-words 100`
+    keeps only the ~long tail (a small, clean third E1 corpus).
+  * Graded monotonicity (`experiments/e_graded.py`): uses the length-robust rules-only
+    `scaled` composite on the A2/B1/original triples; readability reported separately.
+
+Maps to the repo eval schema {title, original, human_translated, corpus} + extra
+metadata (`level`, `article_id`) so the triples are recoverable downstream.
+
+Run:  python -m data_process.apa_lha \
+          --root /path/to/APA_sentence-aligned_LHA
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+# folder name -> CEFR level / simplified-file suffix
+LEVELS = {"A2-OR": "A2", "B1-OR": "B1"}
+
+
+def _dedup_join(path: Path) -> str:
+    """Reconstruct a document from sentence-aligned lines: dedupe, preserve order."""
+    lines = [
+        ln.strip() for ln in path.read_text(encoding="utf-8").splitlines() if ln.strip()
+    ]
+    return " ".join(dict.fromkeys(lines))
+
+
+def build(root: Path) -> int:
+    out = Path("data/apa_lha.json")
+    data: list[dict] = []
+    for folder, level in LEVELS.items():
+        src_dir = root / folder
+        if not src_dir.is_dir():
+            print(f"  skip {folder}: not found under {root}")
+            continue
+        for de_path in sorted(src_dir.glob("*.de")):
+            article_id = de_path.stem  # "<id>_<year>"
+            simp_path = src_dir / f"{article_id}_{level}.simpde"
+            if not simp_path.exists():
+                continue
+            original = _dedup_join(de_path)
+            simple = _dedup_join(simp_path)
+            if not original or not simple:
+                continue
+            data.append(
+                {
+                    "title": f"{article_id}_{level}",
+                    "original": original,
+                    "human_translated": simple,
+                    "corpus": f"apa_lha_{level.lower()}",
+                    "level": level,
+                    "article_id": article_id,
+                }
+            )
+
+    if not data:
+        print(f"No APA-LHA pairs assembled - check --root {root}")
+        return 0
+
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    by_level: dict[str, int] = {}
+    for r in data:
+        by_level[r["corpus"]] = by_level.get(r["corpus"], 0) + 1
+    ids_by_level = {
+        lvl: {r["article_id"] for r in data if r["level"] == lvl}
+        for lvl in ("A2", "B1")
+    }
+    triples = len(ids_by_level["A2"] & ids_by_level["B1"])
+    print(f"Wrote {len(data)} APA-LHA pairs to {out}")
+    for k, v in sorted(by_level.items()):
+        print(f"  {k}: {v}")
+    print(f"  graded triples (article at BOTH A2 and B1): {triples}")
+    return len(data)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--root",
+        required=True,
+        help="path to the APA_sentence-aligned_LHA download (contains A2-OR/, B1-OR/)",
+    )
+    args = ap.parse_args()
+    build(Path(args.root))

data_process/deplain_apa.py

@@ -0,0 +1,127 @@
+"""Build eval datasets from DEplain-APA (Austria Presse Agentur, manually aligned).
+
+DEplain-APA (Stodden et al., ACL 2023) is the **license-restricted** ("upon request",
+Zenodo 7674560) APA news half of DEplain. Unlike the openly-loadable `deplain_web`, it
+ships as a local download, so this converter reads from an extracted `--root` rather than
+HuggingFace.
+
+What it is, and how it relates to our other corpora:
+  * It is a DISTINCT article set from `apa_lha` (the LHA sentence-aligned APA release):
+    we measured 0 exact-document overlap and max trigram-Jaccard ~0.18 (shared news
+    vocabulary only). So it is INDEPENDENT evidence - but the SAME register family
+    (APA news + capito A2/B1). Earned claim = generalization ACROSS ARTICLES within the
+    APA-capito domain, not cross-domain.
+  * It is the clean DOC-LEVEL, MANUALLY-aligned APA corpus that `apa_lha` could not be
+    (apa_lha is sentence-reconstructed, mostly sub-MW100). Genuine complement.
+
+Doc-level structure (`B__Document-level_Corpus/DEplain-APA-doc/plain-text/`):
+  `original` = complex source (assessed B1), `simplification` = target (A2). These are
+  real source->simplification pairs, just with a register-assessed source (narrower
+  dynamic range than standard->A2). Only ONE simplification level per source -> NO graded
+  ladder, so E-GRADED does not apply here (it collapses to the paired validation test).
+
+Sentence-level (`E__Sentence-level_Corpus/DEplain-APA-sent/`): 13,122 manually aligned
+sentence pairs. Ingested for preservation / later reference-based use; the test split's
+`references` are SINGLE-reference (no multi-ref SARI advantage).
+
+We map both to the repo eval schema {title, original, human_translated, corpus} + extra
+metadata (`complex_level`, `simple_level`, `split`, `pair_id`) so splits/pairs are
+recoverable downstream.
+
+Run:
+    python -m data_process.deplain_apa \
+        --root /path/to/DEPlain
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+from pathlib import Path
+
+csv.field_size_limit(10**7)
+
+SPLITS = ("train", "dev", "test")
+DOC_SUBDIR = "B__Document-level_Corpus/DEplain-APA-doc/plain-text"
+SENT_SUBDIR = "E__Sentence-level_Corpus/DEplain-APA-sent"
+
+
+def _read_split(csv_path: Path) -> list[dict]:
+    with csv_path.open(encoding="utf-8") as f:
+        return list(csv.DictReader(f))
+
+
+def _build(root: Path, subdir: str, corpus: str, key: str) -> int:
+    """Convert one DEplain-APA level (doc or sent) to the eval schema.
+
+    Reads per-split CSVs (train/dev/test) so the `split` tag is preserved; each row's
+    `original`/`simplification` columns become `original`/`human_translated`.
+    """
+    src_dir = root / subdir
+    out = Path(f"data/{key}.json")
+    data: list[dict] = []
+    for split in SPLITS:
+        csv_path = src_dir / f"{split}.csv"
+        if not csv_path.exists():
+            print(f"  skip {key}/{split}: not found at {csv_path}")
+            continue
+        for i, row in enumerate(_read_split(csv_path)):
+            original = (row.get("original") or "").strip()
+            simple = (row.get("simplification") or "").strip()
+            if not original or not simple:
+                continue
+            data.append(
+                {
+                    "title": f"{corpus}:{split}:{i}",
+                    "original": original,
+                    "human_translated": simple,
+                    "corpus": corpus,
+                    "complex_level": row.get("complex_level")
+                    or row.get("language_level_original"),
+                    "simple_level": row.get("simple_level")
+                    or row.get("language_level_simple"),
+                    "split": split,
+                    "pair_id": row.get("pair_id"),
+                }
+            )
+
+    if not data:
+        print(f"No {key} pairs assembled - check --root {root}")
+        return 0
+
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    by_split: dict[str, int] = {}
+    for r in data:
+        by_split[r["split"]] = by_split.get(r["split"], 0) + 1
+    print(f"Wrote {len(data)} {key} pairs to {out}")
+    print("  by split: " + ", ".join(f"{k}={v}" for k, v in sorted(by_split.items())))
+    return len(data)
+
+
+def build(root: Path, levels: tuple[str, ...] = ("doc", "sent")) -> None:
+    if "doc" in levels:
+        _build(root, DOC_SUBDIR, "deplain_apa", "deplain_apa")
+    if "sent" in levels:
+        _build(root, SENT_SUBDIR, "deplain_apa_sent", "deplain_apa_sent")
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--root",
+        required=True,
+        help="path to the extracted DEPlain download (contains "
+        "B__Document-level_Corpus/, E__Sentence-level_Corpus/)",
+    )
+    ap.add_argument(
+        "--levels",
+        nargs="+",
+        choices=("doc", "sent"),
+        default=["doc", "sent"],
+        help="which level(s) to build (default: both)",
+    )
+    args = ap.parse_args()
+    build(Path(args.root), tuple(args.levels))

data_process/deplain_web.py

@@ -0,0 +1,71 @@
+"""Build an eval dataset from DEplain-web-doc (German plain-language doc pairs).
+
+DEplain-web-doc (Stodden et al., ACL 2023) is openly loadable from HuggingFace with no
+auth. Each row has an `original` (complex) and a `simplification` (Einfache/Leichte
+Sprache) German document, plus CEFR levels and a `corpus` (subcorpus) tag we keep for
+register filtering.
+
+We map to the repo's eval-dataset schema ({title, original, human_translated}) and keep
+`corpus`/`complex_level`/`simple_level` as extra metadata. This materializes the human original/simplified pairs only.
+
+Run:
+    python -m data_process.deplain_web
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+HF_DATASET = "DEplain/DEplain-web-doc"
+SPLITS = ("train", "validation", "test")
+
+
+def create_deplain_web_json(splits: tuple[str, ...] = SPLITS) -> int:
+    """Load DEplain-web-doc (all splits by default) and write the eval dataset.
+    Returns the number of records written.
+    """
+    from datasets import load_dataset
+
+    out_path = Path("data/deplain_web.json")
+    data: list[dict] = []
+    for split in splits:
+        ds = load_dataset(HF_DATASET, split=split)
+        for i, row in enumerate(ds):
+            original = (row.get("original") or "").strip()
+            simplified = (row.get("simplification") or "").strip()
+            if not original or not simplified:
+                continue
+            corpus = row.get("corpus", "")
+            data.append(
+                {
+                    "title": f"{corpus}:{split}:{i}",
+                    "original": original,
+                    "human_translated": simplified,
+                    "corpus": corpus,
+                    "complex_level": row.get("complex_level"),
+                    "simple_level": row.get("simple_level"),
+                    "split": split,
+                }
+            )
+
+    if not data:
+        print("No DEplain-web records assembled - check dataset access.")
+        return 0
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    by_corpus: dict[str, int] = {}
+    for d in data:
+        by_corpus[d["corpus"]] = by_corpus.get(d["corpus"], 0) + 1
+    print(f"Wrote {len(data)} pairs to {out_path}")
+    print(
+        "By subcorpus: " + ", ".join(f"{k}={v}" for k, v in sorted(by_corpus.items()))
+    )
+    return len(data)
+
+
+if __name__ == "__main__":
+    create_deplain_web_json()

data_process/toborek.py

@@ -0,0 +1,126 @@
+"""Build an eval dataset from the Toborek "A New Aligned Simple German Corpus".
+
+Two sources from a clone of https://github.com/mlai-bonn/Simple-German-Corpus :
+  --hand-aligned : ready text in <repo>/results/hand_aligned/*.{normal,simple} (≈39
+                   pairs), NO crawl. Documents reconstructed by de-duplicating the
+                   alignment lines (a sentence repeats across alignment rows).
+  --full         : after running the crawler, read document pairs from the parsed
+                   articles (implemented once the crawl output is available).
+
+Maps to the repo eval schema {title, original, human_translated, corpus}.
+
+Run:  python -m data_process.toborek --hand-aligned /tmp/Simple-German-Corpus
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def _dedup_join(path: Path) -> str:
+    lines = [
+        ln.strip() for ln in path.read_text(encoding="utf-8").splitlines() if ln.strip()
+    ]
+    return " ".join(dict.fromkeys(lines))  # dedupe, preserve order
+
+
+def build_full(repo: Path) -> int:
+    """Build pairs from the crawled+parsed corpus.
+
+    Walks every ``Datasets/<source>/parsed_header.json`` (mirrors the upstream
+    ``matching/utilities.py:get_article_pairs``): each *easy* entry with
+    ``matching_files`` yields one (easy, normal) pair per matched normal article.
+    easy → human_translated (simplified), normal → original. ``corpus`` is the
+    source domain so the cluster-aware bootstrap sees real subcorpora.
+    """
+    datasets = repo / "Datasets"
+    out = Path("data/toborek.json")
+    data: list[dict] = []
+    seen: set[tuple[str, str]] = set()
+    for header in sorted(datasets.glob("*/parsed_header.json")):
+        src = header.parent.name
+        parsed = header.parent / "parsed"
+        entries = json.loads(header.read_text(encoding="utf-8"))
+        for fname, meta in entries.items():
+            if not meta.get("easy") or not meta.get("matching_files"):
+                continue
+            easy_path = parsed / f"{fname}.txt"
+            if not easy_path.exists():
+                continue
+            simple = _dedup_join(easy_path)
+            if not simple:
+                continue
+            for normal_name in meta["matching_files"]:
+                normal_path = parsed / f"{normal_name}.txt"
+                if not normal_path.exists():
+                    continue
+                original = _dedup_join(normal_path)
+                if not original:
+                    continue
+                key = (original, simple)
+                if key in seen:
+                    continue
+                seen.add(key)
+                data.append(
+                    {
+                        "title": fname,
+                        "original": original,
+                        "human_translated": simple,
+                        "corpus": f"toborek_{src}",
+                        "type": meta.get("type"),  # "LS" (Leichte) or "ES" (Einfache)
+                    }
+                )
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    by_src: dict[str, int] = {}
+    for r in data:
+        by_src[r["corpus"]] = by_src.get(r["corpus"], 0) + 1
+    print(f"Wrote {len(data)} full Toborek pairs to {out}")
+    for k, v in sorted(by_src.items()):
+        print(f"  {k}: {v}")
+    return len(data)
+
+
+def build_hand_aligned(repo: Path) -> int:
+    ha = repo / "results" / "hand_aligned"
+    out = Path("data/toborek.json")
+    data = []
+    for simple in sorted(ha.glob("*.simple")):
+        normal = simple.with_suffix(".normal")
+        if not normal.exists():
+            continue
+        o, s = _dedup_join(normal), _dedup_join(simple)
+        if o and s:
+            data.append(
+                {
+                    "title": simple.stem,
+                    "original": o,
+                    "human_translated": s,
+                    "corpus": "toborek_hand",
+                }
+            )
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"Wrote {len(data)} hand-aligned Toborek pairs to {out}")
+    return len(data)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--hand-aligned", metavar="REPO", help="path to Simple-German-Corpus clone"
+    )
+    ap.add_argument(
+        "--full",
+        metavar="REPO",
+        help="path to crawled+parsed Simple-German-Corpus clone",
+    )
+    args = ap.parse_args()
+    if args.full:
+        build_full(Path(args.full))
+    elif args.hand_aligned:
+        build_hand_aligned(Path(args.hand_aligned))
+    else:
+        ap.error("provide --full <repo path> or --hand-aligned <repo path>")

docs/DATASETS.md

@@ -0,0 +1,65 @@
+# Datasets
+
+The bundle ships text-free scores, not texts. This page is only for people who hold (or can obtain) a license for the underlying corpora and want to see the text behind a given score. Rebuilding a corpus lets you audit provenance; it does **not** let you recompute the scores, because the scorer is closed.
+
+We redistribute no source text, no simplified text, and no competitor model outputs, only numeric features derived from them. The commands below are access instructions, not a grant of rights: obtain each corpus under its own license.
+
+## The corpora
+
+| Corpus (`dataset` key)                                                     | Access                    | What it is                                                                                                                                                                                                                              |
+| -------------------------------------------------------------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [**deplain_web**](https://huggingface.co/datasets/DEplain/DEplain-web-doc) | open, scriptable          | DEplain-web-doc (Stodden et al., ACL 2023): German plain-language document pairs, loadable from HuggingFace with no auth.                                                                                                               |
+| [**toborek**](https://github.com/mlai-bonn/Simple-German-Corpus)           | public clone              | Toborek et al., "A New Aligned Simple German Corpus": from the public `mlai-bonn/Simple-German-Corpus` repo.                                                                                                                            |
+| **apa_lha**                                                                | restricted (author-gated) | APA-LHA (Spring/Stodden): the CEFR-graded (A2/B1) sentence-aligned release of the APA news corpus. Obtain the `APA_sentence-aligned_LHA` release from the authors. Used doc-level (min-words 100) and for the graded-monotonicity test. |
+| [**deplain_apa**](https://zenodo.org/records/7674560)                      | restricted (on request)   | DEplain-APA (Stodden et al., ACL 2023): the license-restricted APA half of DEplain, on request via Zenodo `7674560`.                                                                                                                    |
+
+Builder scripts are in [`data_process/`](../data_process/) and are scorer-free: they only map raw sources into the eval schema, with no scorer import.
+
+## How a bundle row maps to a text (`item_id`)
+
+Each bundle row's `item_id` is `"<dataset>:<pair_idx>:<side>"`:
+
+- `pair_idx`: the 0-based index of the record in that dataset's built `eval_dataset.json` (unfiltered, in file order).
+- `side`: `orig` = the record's `original`, `simp` = its `human_translated`.
+
+So once you rebuild a corpus, `item_id` `deplain_apa:12:simp` is the `human_translated` field of the 13th record of `data/deplain_apa.json`. Row metadata (`sub`, `meta.level`, `meta.article_id`, `meta.split`) travels in the bundle, so filtering and grouping are reproducible from the bundle alone.
+
+## Rebuilding each corpus
+
+### deplain_web (open, fully scriptable)
+
+```bash
+python -m data_process.deplain_web
+# -> data/deplain_web.json  (HF: DEplain/DEplain-web-doc)
+```
+
+This is the only builder that needs a dependency beyond the analysis stack: `pip install datasets`.
+
+### toborek (clone the public corpus, then build)
+
+```bash
+git clone https://github.com/mlai-bonn/Simple-German-Corpus /tmp/Simple-German-Corpus
+python -m data_process.toborek --hand-aligned /tmp/Simple-German-Corpus
+# use --full <clone> instead, after running that repo's crawler, for the complete set
+```
+
+### apa_lha (obtain the APA-LHA release, then build)
+
+Obtain the `APA_sentence-aligned_LHA` release (Spring/Stodden; APA news, author-gated). It extracts to a folder containing `A2-OR/` and `B1-OR/`.
+
+```bash
+python -m data_process.apa_lha --root /path/to/APA_sentence-aligned_LHA
+```
+
+### deplain_apa (request via Zenodo, then build)
+
+Request access to [Zenodo 7674560](https://zenodo.org/records/7674560) (DEplain-APA) and extract the `DEPlain` download (contains `B__Document-level_Corpus/`, `E__Sentence-level_Corpus/`).
+
+```bash
+python -m data_process.deplain_apa --root /path/to/DEPlain
+```
+
+## Not included here
+
+- **Competitor model outputs** (erlesen, German4all, ELGEPA, capito): not redistributed (erlesen ships with no declared license). The paper documents each model's checkpoint and decoding contract so they can be regenerated from the public model weights.
+- **`deplain_apa_sent`** (13k sentence pairs) and **`simpevalde`**: used only by reference-based metrics (EASSE-DE SARI/BLEU/BERTScore), which are standard and open; they are not part of the closed-scorer bundle.

docs/REPRODUCE.md

@@ -0,0 +1,65 @@
+# Reproduce
+
+Every metric table in the paper comes from the released, text-free score bundles in `scores/`. No closed scorer and no restricted corpus is needed. Install the analysis stack (`pip install -r requirements.txt`) and run the commands below from the repo root. To see the text behind a score, see [`DATASETS.md`](./DATASETS.md).
+
+Each script maps to one research question in the paper.
+
+## RQ1 - does the metric separate simplified from original, and does the confidence weighting help?
+
+```bash
+python -m experiments.rq1_validate --dataset deplain_web --scores scores/deplain_web.jsonl
+```
+
+Same for the other corpora, swapping `--dataset` and the bundle path:
+
+```bash
+python -m experiments.rq1_validate --dataset toborek     --scores scores/toborek.jsonl
+python -m experiments.rq1_validate --dataset apa_lha     --scores scores/apa_lha.jsonl
+python -m experiments.rq1_validate --dataset deplain_apa --scores scores/deplain_apa.jsonl
+```
+
+Writes `results/validation_stats_<dataset>_mw100.json` and prints the discrimination and ablation report to stdout.
+
+## RQ2 - convergent validity vs. standard readability indices
+
+Canonical two-corpus run (toborek + deplain_web, matches the paper's figure):
+
+```bash
+python -m experiments.rq2_convergent --scores-dir scores
+```
+
+Single-corpus run (any one dataset, e.g. apa_lha):
+
+```bash
+python -m experiments.rq2_convergent --dataset apa_lha --scores-dir scores
+```
+
+Writes `results/rq2_convergent.json` (plus a `.png` scatter), or `results/rq2_convergent_<dataset>.json`.
+
+## RQ3 - graded monotonicity across CEFR bands
+
+```bash
+python -m experiments.rq3_graded --scores scores/apa_lha.jsonl
+```
+
+Writes `results/rq3_graded.json`.
+
+## RQ4 - competitor comparison and equivalence test
+
+Reads the `scores/competitors.jsonl` bundle (one row per (dataset, item, system): source/human/KLAR plus competitor models). Defaults to `--datasets toborek,deplain_web` (n=514), matching the paper's as-submitted table.
+
+```bash
+python -m experiments.rq4_competitors
+python -m experiments.rq4_tost
+```
+
+Writes `results/rq4_competitors/summary.json` and `results/rq4_tost.json`, and prints the head-to-head (composite plus independent Flesch) and TOST equivalence reports.
+
+For the pooled n=997 variant (DEplain-APA pooled in after submission), pass the same `--datasets` to both, since `rq4_tost.py`'s self-test reconciles against `rq4_competitors`' `summary.json`:
+
+```bash
+python -m experiments.rq4_competitors --datasets toborek,deplain_web,deplain_apa
+python -m experiments.rq4_tost --datasets toborek,deplain_web,deplain_apa
+```
+
+Competitor subsets are selectable independently of dataset scope, e.g. `--systems capito`.

experiments/eval_filters.py

@@ -0,0 +1,20 @@
+"""Corpus-filter constants for the paper eval (released path, no scorer import).
+
+They are pure eval configuration, kept separate from the (closed-scorer-importing)
+modules so the released analysis path can import them without touching the scorer.
+"""
+
+from __future__ import annotations
+
+# Drop these subcorpora / title substrings before any paper statistic.
+EXCLUDE_CORPUS = {"bible_workin_progress", "bible_awaiting_proof"}
+EXCLUDE_SUBSTR = ("Märchen", "Marchen")
+
+
+def keep(rec: dict) -> bool:
+    """The paper's corpus filter: drop excluded subcorpora / fairy-tale titles.
+    `rec` needs only a `corpus` field (bundle rows pass `{"corpus": row["sub"]}`)."""
+    c = rec.get("corpus", "") or ""
+    if c in EXCLUDE_CORPUS:
+        return False
+    return all(sub.lower() not in c.lower() for sub in EXCLUDE_SUBSTR)

experiments/rq1_validate.py

@@ -0,0 +1,311 @@
+"""RQ1 - validation of the KLAR composite with proper inferential statistics.
+
+Reads a text-free scores bundle, then runs:
+  discrimination  metric separates simplified from original (paired Wilcoxon, bootstrap CIs on Δ, d, AUC).
+  normalization   raw vs scaled vs scaled+conf (bootstrap CI on AUC differences).
+  per-rule           - Wilcoxon per rule + Benjamini-Hochberg FDR.
+  readability        - reported SEPARATELY and RAW (standard general indices, NOT
+                       calibrated, NOT in the composite).
+  robustness         - per-subcorpus breakdown; CIs are cluster-aware (by subcorpus).
+
+Composite (the metric) = confidence-weighted mean of the 20 rules' `scaled` only.
+
+This is the released path: it reads precomputed per-document scores from a `--scores`
+bundle. The scorer itself is closed and not included in this release.
+
+Run:  python -m experiments.rq1_validate --scores scores/deplain_web.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+from experiments.eval_filters import keep
+from experiments.stats_utils import (
+    auc,
+    bh_fdr,
+    cluster_bootstrap_ci,
+    cohens_d_paired,
+    wilcoxon_p,
+)
+
+LOWER_IS_SIMPLER = {"lix", "wiener_sachtextformel"}
+READABILITY = {"flesch", "lix", "wiener_sachtextformel"}
+RESULTS_DIR = Path("results")
+VARIANTS = ("raw", "scaled", "scaled_conf")
+
+# `keep` is imported from eval_filters (re-exported here so `VM.keep` callers still work).
+
+
+def comps(rules: dict) -> dict[str, float]:
+    v = list(rules.values())
+    num = sum(x["scaled"] * x["w"] for x in v)
+    den = sum(x["w"] for x in v)
+    return {
+        "raw": float(np.mean([x["raw"] for x in v])),
+        "scaled": float(np.mean([x["scaled"] for x in v])),
+        "scaled_conf": num / den if den else float("nan"),
+    }
+
+
+def recs_from_bundle(rows: list[dict], mw: int) -> tuple[list[dict], dict, dict]:
+    """Reconstruct (recs, read_pairs, rule_deltas) from a text-free scores bundle -
+    the released equivalent of the live scoring loop. Applies the same
+    keep() + min_words filters, so the downstream statistics are identical."""
+    from experiments.scores_bundle import kept_pairs
+
+    recs: list[dict] = []
+    read_pairs: dict[str, list] = {r: [] for r in READABILITY}
+    rule_deltas: dict[str, list] = {}
+    for orig, simp in kept_pairs(rows, mw):
+        recs.append(
+            {
+                "sub": orig["sub"],
+                "register": orig["register"],
+                "co": orig["composite"],
+                "cs": simp["composite"],
+            }
+        )
+        po, ps = orig["per_rule"], simp["per_rule"]
+        for rule in po.keys() & ps.keys():
+            rule_deltas.setdefault(rule, []).append(
+                ps[rule]["scaled"] - po[rule]["scaled"]
+            )
+        for rn in READABILITY:
+            if rn in orig["readability"] and rn in simp["readability"]:
+                read_pairs[rn].append((orig["readability"][rn], simp["readability"][rn]))
+    return recs, read_pairs, rule_deltas
+
+
+def register_label(rec: dict) -> str | None:
+    """Return the source-provided register label, if the dataset carries one."""
+    label = rec.get("type") or rec.get("register")
+    return str(label) if label else None
+
+
+def attach_registers_from_pairs(recs: list[dict], pairs: list[dict]) -> None:
+    """Backfill register metadata when loading scored caches written before it existed."""
+    for scored, source in zip(recs, pairs, strict=False):
+        scored.setdefault("register", register_label(source))
+
+
+def register_breakdown(recs: list[dict]) -> dict[str, dict[str, float | int]]:
+    regs: dict[str, list[dict]] = {}
+    for r in recs:
+        register = r.get("register")
+        if not register:
+            continue
+        regs.setdefault(register, []).append(r)
+
+    out = {}
+    for reg, rows in sorted(regs.items()):
+        deltas_reg = deltas_of(rows, "scaled_conf")
+        out[reg] = {
+            "n": len(rows),
+            "mean_delta": float(np.mean(deltas_reg)),
+            "auc": auc_of(rows, "scaled_conf"),
+            "pct_simpler": 100 * float(np.mean([x > 0 for x in deltas_reg])),
+            "wilcoxon_p_onesided": wilcoxon_p(deltas_reg, "greater"),
+        }
+    return out
+
+
+def subcorpus_breakdown(recs: list[dict]) -> dict[str, dict[str, float | int]]:
+    subs: dict[str, list[float]] = {}
+    for r in recs:
+        subs.setdefault(r["sub"], []).append(
+            r["cs"]["scaled_conf"] - r["co"]["scaled_conf"]
+        )
+    return {
+        s: {
+            "n": len(v),
+            "mean_delta": float(np.mean(v)),
+            "pct_simpler": 100 * float(np.mean([x > 0 for x in v])),
+        }
+        for s, v in sorted(subs.items())
+    }
+
+
+def main(argv: list[str] | None = None) -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dataset", default="deplain_web", help="dataset label (for output naming)")
+    ap.add_argument(
+        "--scores",
+        required=True,
+        help="text-free per-doc scores bundle (JSONL) - the released "
+        "reproducibility path.",
+    )
+    ap.add_argument(
+        "--min-words",
+        type=int,
+        default=100,
+        help="drop pairs where either text has < N words. Default 100: below "
+        "this the readability indices (Flesch/WSF/LIX) are not valid and the "
+        "confidence weight n/(n+n0) degenerates. Use 0 to disable.",
+    )
+    args = ap.parse_args(argv)
+    mw = args.min_words
+    suffix = f"_{args.dataset}" + (f"_mw{mw}" if mw else "")
+
+    from experiments.scores_bundle import load_rows
+
+    recs, read_pairs, rule_deltas = recs_from_bundle(load_rows(args.scores), mw)
+    print(
+        f"[{args.dataset}] {len(recs)} pairs from scores bundle "
+        f"({args.scores}); released path, min_words>={mw}."
+    )
+
+    sub = lambda r: r["sub"]  # noqa: E731  cluster key
+
+    def deltas(v):
+        return [r["cs"][v] - r["co"][v] for r in recs]
+
+    # ---- discrimination: does the metric (scaled_conf) separate simp from orig? ----
+    d_full = deltas("scaled_conf")
+    e1 = {
+        "n": len(recs),
+        "mean_delta": float(np.mean(d_full)),
+        "cohens_d": cohens_d_paired(d_full),
+        "auc": auc_of(recs, "scaled_conf"),
+        "pct_simpler": 100 * float(np.mean([x > 0 for x in d_full])),
+        "wilcoxon_p_onesided": wilcoxon_p(d_full, "greater"),
+        "ci_mean_delta": cluster_bootstrap_ci(
+            recs, lambda rs: float(np.mean(deltas_of(rs, "scaled_conf"))), sub
+        ),
+        "ci_cohens_d": cluster_bootstrap_ci(
+            recs, lambda rs: cohens_d_paired(deltas_of(rs, "scaled_conf")), sub
+        ),
+        "ci_auc": cluster_bootstrap_ci(recs, lambda rs: auc_of(rs, "scaled_conf"), sub),
+    }
+
+    # ---- normalization ablation, with bootstrap CI on AUC differences ----
+    e2 = {
+        v: {"auc": auc_of(recs, v), "cohens_d": cohens_d_paired(deltas(v))}
+        for v in VARIANTS
+    }
+    diffs = {}
+    for a, b in (("scaled_conf", "raw"), ("scaled", "raw"), ("scaled_conf", "scaled")):
+        point = auc_of(recs, a) - auc_of(recs, b)
+        ci = cluster_bootstrap_ci(
+            recs, lambda rs, a=a, b=b: auc_of(rs, a) - auc_of(rs, b), sub
+        )
+        diffs[f"{a}_minus_{b}"] = {
+            "delta_auc": point,
+            "ci": ci,
+            "significant": ci[0] > 0 or ci[1] < 0,
+        }
+
+    # non-inferiority / equivalence (TOST-style): 90% CI of ΔAUC(full − raw).
+    # "not worse" if 90% CI lower bound > −margin; "equivalent" if 90% CI ⊂ [−m, +m].
+    eq90 = cluster_bootstrap_ci(
+        recs, lambda rs: auc_of(rs, "scaled_conf") - auc_of(rs, "raw"), sub, alpha=0.10
+    )
+    equivalence = {
+        "delta_auc_full_minus_raw": auc_of(recs, "scaled_conf") - auc_of(recs, "raw"),
+        "ci90": eq90,
+        "not_worse_at_margin_0.03": eq90[0] > -0.03,
+        "equivalent_at_margin_0.05": eq90[0] > -0.05 and eq90[1] < 0.05,
+    }
+
+    # ---- per-rule Wilcoxon + BH-FDR ----
+    rule_names = list(rule_deltas)
+    pvals = [wilcoxon_p(rule_deltas[r], "two-sided") for r in rule_names]
+    adj = bh_fdr([p if p == p else 1.0 for p in pvals])  # nan->1
+    per_rule = sorted(
+        (
+            {
+                "rule": rn,
+                "mean_delta": float(np.mean(rule_deltas[rn])),
+                "p": pvals[k],
+                "fdr": float(adj[k]),
+            }
+            for k, rn in enumerate(rule_names)
+        ),
+        key=lambda x: x["fdr"],
+    )
+
+    # ---- readability (separate, raw, NOT in composite) ----
+    readability = {}
+    for rn, pr in read_pairs.items():
+        if not pr:
+            continue
+        do = [b - a for a, b in pr]
+        readability[rn] = {
+            "raw_orig_mean": float(np.mean([a for a, _ in pr])),
+            "raw_simp_mean": float(np.mean([b for _, b in pr])),
+            "wilcoxon_p_onesided": wilcoxon_p(do, "greater"),
+            "note": "sign-corrected so higher=simpler; reported raw, standard index",
+        }
+
+    # ---- robustness: per-subcorpus ----
+    per_sub = subcorpus_breakdown(recs)
+    per_register = register_breakdown(recs)
+
+    out = {
+        "discrimination": e1,
+        "normalization_ablation": {"variants": e2, "auc_diffs": diffs, "equivalence": equivalence},
+        "per_rule_fdr": per_rule,
+        "readability_separate": readability,
+        "per_subcorpus": per_sub,
+    }
+    if per_register:
+        out["per_register"] = per_register
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = RESULTS_DIR / f"validation_stats{suffix}.json"
+    out_path.write_text(json.dumps(out, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    # ---- report ----
+    print("\n=== RQ1 discrimination: metric separates simplified from original ===")
+    print(f"n={e1['n']}  mean Δ={e1['mean_delta']:+.3f} CI{_f(e1['ci_mean_delta'])}")
+    print(
+        f"Cohen's d={e1['cohens_d']:.2f} CI{_f(e1['ci_cohens_d'])}  "
+        f"AUC={e1['auc']:.3f} CI{_f(e1['ci_auc'])}"
+    )
+    print(
+        f"%pairs simpler={e1['pct_simpler']:.0f}%  Wilcoxon p(one-sided)={e1['wilcoxon_p_onesided']:.2e}"
+    )
+    print("\n=== RQ1 normalization ablation (AUC, is the gain significant?) ===")
+    for v in VARIANTS:
+        print(f"  {v:<12} AUC={e2[v]['auc']:.3f}  d={e2[v]['cohens_d']:.2f}")
+    for k, dd in diffs.items():
+        sig = "SIGNIFICANT" if dd["significant"] else "n.s."
+        print(f"  Δ {k}: {dd['delta_auc']:+.3f} CI95{_f(dd['ci'])} -> {sig}")
+    eq = equivalence
+    print(
+        f"  non-inferiority: ΔAUC(full−raw)={eq['delta_auc_full_minus_raw']:+.3f} "
+        f"CI90{_f(eq['ci90'])}  not-worse@0.03={eq['not_worse_at_margin_0.03']}  "
+        f"equiv@0.05={eq['equivalent_at_margin_0.05']}"
+    )
+    print("\n=== per-rule (BH-FDR), top by significance ===")
+    for r in per_rule[:10]:
+        star = "*" if r["fdr"] < 0.05 else " "
+        print(
+            f" {star} {r['rule']:<32}Δ={r['mean_delta']:+.3f}  p={r['p']:.1e}  fdr={r['fdr']:.1e}"
+        )
+    print("\n=== readability (separate, raw, NOT calibrated) ===")
+    for rn, rr in readability.items():
+        print(
+            f"  {rn:<22}orig={rr['raw_orig_mean']:+.2f} simp={rr['raw_simp_mean']:+.2f} "
+            f"p={rr['wilcoxon_p_onesided']:.1e}"
+        )
+    print(f"\nWrote {out_path}")
+
+
+def deltas_of(rs, v):
+    return [r["cs"][v] - r["co"][v] for r in rs]
+
+
+def auc_of(rs, v):
+    return auc([r["cs"][v] for r in rs], [r["co"][v] for r in rs])
+
+
+def _f(ci):
+    return f"[{ci[0]:.3f},{ci[1]:.3f}]"
+
+
+if __name__ == "__main__":
+    main()

experiments/rq2_convergent.py

@@ -0,0 +1,210 @@
+"""RQ2 - convergent validity of the KLAR composite vs. standard readability indices.
+
+Two things, on the ≥100-word pairs of both corpora:
+  (1) Convergent validity: does the composite agree with established German readability
+      indices (Flesch-DE, WSF, LIX)? Pearson + Spearman, pooled over all documents
+      (sign-corrected so higher = simpler everywhere).
+  (2) Added signal: do the rules capture simplification that readability misses? Tested
+      three ways: per-pair Δ correlation (<1 ⇒ not redundant), single-index vs composite
+      discrimination AUC, and the composite's discrimination WITHIN the stratum where
+      readability barely moves (low |Δ Flesch| tercile).
+
+Composite = scaled_conf (the reported metric). Readability is RAW (never calibrated).
+Writes results JSON + a scatter figure to docs/plans/paper/results/.
+
+This is the released path: it reads precomputed per-document scores from a
+`--scores-dir` bundle. The scorer itself is closed and not included in this release.
+
+Run:  python -m experiments.rq2_convergent --scores-dir scores
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+from experiments.scores_bundle import kept_pairs, load_rows
+from experiments.stats_utils import auc
+
+MIN_WORDS = 100
+INDICES = ("flesch", "lix", "wiener_sachtextformel")
+RESULTS = Path("results")
+
+
+def _pearson(x, y):
+    return float(np.corrcoef(x, y)[0, 1])
+
+
+def _spearman(x, y):
+    rx, ry = np.argsort(np.argsort(x)), np.argsort(np.argsort(y))
+    return float(np.corrcoef(rx, ry)[0, 1])
+
+
+def _score_bundle(rows: list[dict]):
+    """Per-doc arrays: composite (scaled_conf) + each readability index, plus the
+    paired (orig, simp) split for delta/stratum analysis - read from the text-free
+    scores bundle (released path)."""
+    comp_o, comp_s = [], []
+    rd_o = {k: [] for k in INDICES}
+    rd_s = {k: [] for k in INDICES}
+    for orig, simp in kept_pairs(rows, MIN_WORDS):
+        ro, rs = orig["readability"], simp["readability"]
+        if not all(k in ro and k in rs for k in INDICES):
+            continue
+        comp_o.append(orig["composite"]["scaled_conf"])
+        comp_s.append(simp["composite"]["scaled_conf"])
+        for k in INDICES:
+            rd_o[k].append(ro[k])
+            rd_s[k].append(rs[k])
+    return (
+        np.array(comp_o),
+        np.array(comp_s),
+        {k: np.array(v) for k, v in rd_o.items()},
+        {k: np.array(v) for k, v in rd_s.items()},
+    )
+
+
+def _analyze(ds: str, scores_dir: str):
+    """Run the full RQ2 convergent + added-signal analysis for one corpus.
+
+    Returns (res, co, cs, rdo, rds): the result dict plus the raw per-doc arrays
+    (kept so callers can also draw the scatter). Reads <scores_dir>/<ds>.jsonl.
+    """
+    co, cs, rdo, rds = _score_bundle(load_rows(Path(scores_dir) / f"{ds}.jsonl"))
+    n = len(co)
+    comp = np.concatenate([co, cs])  # pooled docs
+    res = {
+        "n_pairs": n,
+        "convergent": {},
+        "delta_corr": {},
+        "discrimination_auc": {},
+    }
+
+    # (1) convergent validity - pooled docs
+    for k in INDICES:
+        idx = np.concatenate([rdo[k], rds[k]])
+        res["convergent"][k] = {
+            "pearson": _pearson(comp, idx),
+            "spearman": _spearman(comp, idx),
+        }
+    # (2a) per-pair delta correlation (composite Δ vs index Δ)
+    dcomp = cs - co
+    for k in INDICES:
+        didx = rds[k] - rdo[k]
+        res["delta_corr"][k] = {
+            "pearson": _pearson(dcomp, didx),
+            "spearman": _spearman(dcomp, didx),
+        }
+    # (2b) discrimination AUC: composite vs each single index
+    res["discrimination_auc"]["composite"] = auc(list(cs), list(co))
+    for k in INDICES:
+        res["discrimination_auc"][k] = auc(list(rds[k]), list(rdo[k]))
+    # (2c) composite discrimination WHERE readability barely moves (low |Δflesch| tercile)
+    dfl = np.abs(rds["flesch"] - rdo["flesch"])
+    thr = float(np.quantile(dfl, 1 / 3))
+    sel = dfl <= thr
+    res["low_readability_change_stratum"] = {
+        "flesch_abs_delta_threshold": thr,
+        "n": int(sel.sum()),
+        "composite_auc": auc(list(cs[sel]), list(co[sel])),
+        "pct_pairs_composite_simpler": 100 * float(np.mean(dcomp[sel] > 0)),
+    }
+    return res, co, cs, rdo, rds
+
+
+def _print_report(ds: str, r: dict) -> None:
+    print(f"\n=== {ds} (n={r['n_pairs']} pairs) ===")
+    print("convergent (composite vs index, pooled docs):")
+    for k in INDICES:
+        c = r["convergent"][k]
+        print(f"  {k:22s} pearson={c['pearson']:+.3f} spearman={c['spearman']:+.3f}")
+    print("per-pair Δ correlation (composite Δ vs index Δ):")
+    for k in INDICES:
+        c = r["delta_corr"][k]
+        print(f"  {k:22s} pearson={c['pearson']:+.3f} spearman={c['spearman']:+.3f}")
+    a = r["discrimination_auc"]
+    print(
+        "discrimination AUC: composite={:.3f} | flesch={:.3f} lix={:.3f} wsf={:.3f}".format(
+            a["composite"], a["flesch"], a["lix"], a["wiener_sachtextformel"]
+        )
+    )
+    s = r["low_readability_change_stratum"]
+    print(
+        f"low |Δflesch| stratum (n={s['n']}): composite AUC={s['composite_auc']:.3f}, "
+        f"{s['pct_pairs_composite_simpler']:.0f}% pairs composite-simpler "
+        f"→ rules add signal where readability is flat"
+    )
+
+
+def run_single(ds: str, scores_dir: str) -> None:
+    """Run RQ2 for ONE corpus and write a clearly-named, separate artifact.
+
+    Mirrors `main()` exactly for a single dataset (additive parity run); never
+    touches the canonical multi-corpus rq2_convergent.json.
+    """
+    RESULTS.mkdir(parents=True, exist_ok=True)
+    res, *_ = _analyze(ds, scores_dir)
+    out = {ds: res}
+    out_path = RESULTS / f"rq2_convergent_{ds}.json"
+    out_path.write_text(json.dumps(out, ensure_ascii=False, indent=2), encoding="utf-8")
+    _print_report(ds, res)
+    print(f"\nWrote {out_path}")
+
+
+def main(scores_dir: str) -> None:
+    RESULTS.mkdir(parents=True, exist_ok=True)
+    out = {}
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))
+    for ax, ds in zip(axes, ("toborek", "deplain_web"), strict=False):
+        res, co, cs, rdo, rds = _analyze(ds, scores_dir)
+        n = res["n_pairs"]
+        out[ds] = res
+
+        ax.scatter(
+            rdo["flesch"], co, s=10, alpha=0.4, label="original (complex)", color="#c44"
+        )
+        ax.scatter(rds["flesch"], cs, s=10, alpha=0.4, label="simplified", color="#48a")
+        ax.set_title(f"{ds} (n={n})  ρ={res['convergent']['flesch']['spearman']:.2f}")
+        ax.set_xlabel("Flesch-DE (raw, higher=simpler)")
+        ax.set_ylabel("composite (scaled_conf)")
+        ax.legend(fontsize=8)
+    fig.suptitle("RQ2: composite vs. Flesch readability (convergent validity)")
+    fig.tight_layout()
+    fig.savefig(RESULTS / "rq2_convergent.png", dpi=130)
+    (RESULTS / "rq2_convergent.json").write_text(
+        json.dumps(out, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+    # report
+    for ds, r in out.items():
+        _print_report(ds, r)
+    print(f"\nWrote {RESULTS}/rq2_convergent.json + .png")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument(
+        "--dataset",
+        default=None,
+        help="run RQ2 for a single corpus -> rq2_convergent_<dataset>.json "
+        "(default: canonical toborek+deplain_web run -> rq2_convergent.json)",
+    )
+    ap.add_argument(
+        "--scores-dir",
+        required=True,
+        help="read per-doc scores from <scores-dir>/<dataset>.jsonl - the "
+        "released reproducibility path.",
+    )
+    args = ap.parse_args()
+    if args.dataset:
+        run_single(args.dataset, args.scores_dir)
+    else:
+        main(args.scores_dir)

experiments/rq3_graded.py

@@ -0,0 +1,199 @@
+"""RQ3 - ordinal monotonicity of KLAR across CEFR simplification levels.
+
+APA-LHA uniquely gives the SAME article at three levels: original (complex), B1, and
+A2 (1344 articles exist at both A2 and B1). A valid simplicity metric should be monotone
+in level: composite(A2) > composite(B1) > composite(original). This is a stronger claim
+than binary original-vs-simple discrimination; it tests that the metric *grades*.
+
+Why the rules-only `scaled` composite (not `scaled_conf`): the simplified sides are short
+(A2 median ~39 words), so the confidence weight n/(n+n0) degenerates and MW100 would
+discard almost everything. The z-sigmoid `scaled` mean is length-robust (equal-weight,
+no per-doc count), so it is the honest choice here. Readability indices are reported
+SEPARATELY and flagged as out-of-validity-range on the short sides.
+
+The article's "original" is reconstructed twice (once per level folder); we average the
+two original composites since it is the same source article.
+
+This is the released path: it reads precomputed per-document scores from a `--scores`
+bundle. The scorer itself is closed and not included in this release.
+
+Run:  python -m experiments.rq3_graded --scores scores/apa_lha.jsonl
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+from scipy import stats
+
+from experiments.scores_bundle import load_rows, pairs_by_idx
+
+OUT = Path("results/rq3_graded.json")
+
+
+def _bootstrap_ci(vals: list[float], n: int = 5000) -> tuple[float, float]:
+    arr = np.asarray(vals, float)
+    means = [arr[np.random.randint(0, len(arr), len(arr))].mean() for _ in range(n)]
+    return float(np.percentile(means, 2.5)), float(np.percentile(means, 97.5))
+
+
+def _rows_bundle(path: str) -> list[dict]:
+    """Build the per-article triples from the text-free scores bundle (released path).
+
+    For each apa_lha record the bundle carries an 'orig' row (original) and a 'simp'
+    row (simplified at meta.level); we key on meta.article_id, take the rules-only
+    `scaled` composite, and average the per-level original reconstructions."""
+    bundle_rows = load_rows(path)
+
+    def scaled(row: dict) -> float:
+        return row["composite"]["scaled"]
+
+    def flesch(row: dict):
+        return row["readability"].get("flesch")
+
+    by_id: dict[str, dict] = {}
+    for orig, simp in pairs_by_idx(bundle_rows):
+        meta = orig["meta"]
+        a = by_id.setdefault(meta["article_id"], {})
+        a[meta["level"]] = simp  # simplified row at this level
+        a.setdefault("orig", []).append(orig)  # original reconstruction(s)
+
+    triples = {aid: a for aid, a in by_id.items() if "A2" in a and "B1" in a}
+    print(f"[apa_lha] {len(triples)} graded triples (from scores bundle)")
+
+    rows = []
+    for aid, a in triples.items():
+        o = float(np.mean([scaled(r) for r in a["orig"]]))
+        fo = float(
+            np.mean(
+                [flesch(r) for r in a["orig"] if isinstance(flesch(r), int | float)]
+                or [np.nan]
+            )
+        )
+        rows.append(
+            {
+                "id": aid,
+                "orig": o,
+                "B1": scaled(a["B1"]),
+                "A2": scaled(a["A2"]),
+                "fl_orig": fo,
+                "fl_B1": flesch(a["B1"]),
+                "fl_A2": flesch(a["A2"]),
+            }
+        )
+    return rows
+
+
+def _analyze(rows: list[dict]) -> dict:
+    """The monotonicity statistics - a pure function of the triples (bootstrap CIs use the
+    module-level np.random state, so seed it if you need CI-for-CI reproducibility)."""
+    co = np.array([r["orig"] for r in rows])  # composite at original / B1 / A2
+    cb = np.array([r["B1"] for r in rows])
+    ca = np.array([r["A2"] for r in rows])
+
+    # strict monotonic ordering A2 > B1 > original
+    strict = float(np.mean((ca > cb) & (cb > co)) * 100)
+    a2_gt_b1 = float(np.mean(ca > cb) * 100)
+    b1_gt_o = float(np.mean(cb > co) * 100)
+
+    # pairwise paired Wilcoxon (one-sided: simpler level scores higher)
+    def wil(x, y):  # H1: x > y
+        return float(stats.wilcoxon(x, y, alternative="greater").pvalue)
+
+    # Friedman (do the three levels differ?) + per-article Spearman trend (rank vs composite)
+    fr_p = float(stats.friedmanchisquare(co, cb, ca).pvalue)
+    rho = float(
+        stats.spearmanr(
+            np.concatenate([np.zeros_like(co), np.ones_like(cb), 2 * np.ones_like(ca)]),
+            np.concatenate([co, cb, ca]),
+        ).correlation
+    )
+
+    means = {
+        "original": float(co.mean()),
+        "B1": float(cb.mean()),
+        "A2": float(ca.mean()),
+    }
+    cis = {
+        k: _bootstrap_ci(v.tolist())
+        for k, v in (("original", co), ("B1", cb), ("A2", ca))
+    }
+    fl_means = {
+        "original": float(np.nanmean([r["fl_orig"] for r in rows])),
+        "B1": float(
+            np.nanmean([r["fl_B1"] for r in rows if isinstance(r["fl_B1"], int | float)])
+        ),
+        "A2": float(
+            np.nanmean([r["fl_A2"] for r in rows if isinstance(r["fl_A2"], int | float)])
+        ),
+    }
+
+    return {
+        "dataset": "apa_lha",
+        "metric": "scaled (rules-only, length-robust)",
+        "n_triples": len(rows),
+        "mean_composite": means,
+        "composite_ci95": cis,
+        "mean_flesch_separate": fl_means,
+        "pct_strict_monotonic_A2_gt_B1_gt_orig": strict,
+        "pct_A2_gt_B1": a2_gt_b1,
+        "pct_B1_gt_orig": b1_gt_o,
+        "wilcoxon_p": {
+            "A2>B1": wil(ca, cb),
+            "B1>orig": wil(cb, co),
+            "A2>orig": wil(ca, co),
+        },
+        "friedman_p": fr_p,
+        "spearman_level_vs_composite": rho,
+    }
+
+
+def main(scores: str) -> None:
+    rows = _rows_bundle(scores)
+    result = _analyze(rows)
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    means, fl_means = result["mean_composite"], result["mean_flesch_separate"]
+    print(
+        "\n=== RQ3 graded: monotonicity across original > B1 > A2 (scaled composite) ==="
+    )
+    print(f"n={result['n_triples']} triples")
+    print(
+        f"  mean composite: original {means['original']:.3f} | "
+        f"B1 {means['B1']:.3f} | A2 {means['A2']:.3f}"
+    )
+    print(
+        f"  Flesch (separate): original {fl_means['original']:.0f} | "
+        f"B1 {fl_means['B1']:.0f} | A2 {fl_means['A2']:.0f}"
+    )
+    print(
+        f"  strict monotonic (A2>B1>orig): "
+        f"{result['pct_strict_monotonic_A2_gt_B1_gt_orig']:.0f}%  "
+        f"(A2>B1 {result['pct_A2_gt_B1']:.0f}%, B1>orig {result['pct_B1_gt_orig']:.0f}%)"
+    )
+    print(
+        f"  Wilcoxon: A2>B1 p={result['wilcoxon_p']['A2>B1']:.1e}, "
+        f"B1>orig p={result['wilcoxon_p']['B1>orig']:.1e}"
+    )
+    print(
+        f"  Friedman p={result['friedman_p']:.1e}  |  "
+        f"Spearman(level,composite)={result['spearman_level_vs_composite']:.3f}"
+    )
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument(
+        "--scores",
+        required=True,
+        help="path to the apa_lha scores bundle (scores/apa_lha.jsonl) - the "
+        "released reproducibility path.",
+    )
+    args = ap.parse_args()
+    main(args.scores)

experiments/rq4_competitors.py

@@ -0,0 +1,244 @@
+"""RQ4 - competitor comparison: rank competitor system outputs head-to-head against
+KLAR, the human reference, and the source, from the released text-free score bundle.
+
+Pairing: every competitor output is matched to a source/human/KLAR quadruple by
+(dataset, record-index i, system), read straight off `scores/competitors.jsonl`. This
+script only reads the bundle; it imports no scorer code and never reads raw corpora.
+
+Two competitor sources, both bundled the same way:
+  * capito:   manual paste, n=3 (free-tier capped). Qualitative only.
+  * hf models: batch-generated.
+
+Circularity caveat: the composite is what KLAR's Supervisor optimises toward; competitors
+do not. A KLAR>competitor *composite* win is partly teaching-to-the-test. This script reports
+the composite AND the independent Flesch; the Flesch comparison is the one to headline. Do not
+state "KLAR beats X" on composite alone.
+
+Dataset scope: defaults to `--datasets toborek,deplain_web` (n=514), matching the paper's
+as-submitted table. Pass `--datasets toborek,deplain_web,deplain_apa` for the pooled n=997
+variant (DEplain-APA pooled in later).
+
+Run:  python -m experiments.rq4_competitors --systems capito
+      python -m experiments.rq4_competitors --systems German4all,erlesen-leo-13b
+      python -m experiments.rq4_competitors --datasets toborek,deplain_web,deplain_apa
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+from experiments.scores_bundle import load_rows, systems_by_item
+from experiments.stats_utils import bh_fdr, cluster_bootstrap_ci, wilcoxon_p
+
+OUT = Path("results/rq4_competitors")
+SCORES = Path("scores/competitors.jsonl")
+HEADLINE_SYSTEMS = "German4all,erlesen-leo-7b,erlesen-leo-13b,elgepa-8b"
+DEFAULT_DATASETS = "toborek,deplain_web"
+
+
+def _rec_metric(row: dict) -> dict:
+    return {
+        "composite": row["composite"]["scaled_conf"],
+        "flesch": row["readability"]["flesch"],
+        "words": row["n_words"],
+    }
+
+
+def _build_recs(system: str, by_item: dict[tuple[str, int], dict[str, dict]]) -> list[dict]:
+    """Rebuild the paired source/human/KLAR/competitor records for one system from
+    the bundle - the same shape _score_system used to build inline."""
+    recs = []
+    for (dataset, i), systems in by_item.items():
+        if system not in systems:
+            continue
+        if not all(s in systems for s in ("source", "human", "KLAR")):
+            continue
+        row = systems[system]
+        recs.append(
+            {
+                "dataset": dataset,
+                "i": i,
+                "sub": row.get("sub") or "?",
+                "source": _rec_metric(systems["source"]),
+                "human": _rec_metric(systems["human"]),
+                "KLAR": _rec_metric(systems["KLAR"]),
+                "competitor": _rec_metric(row),
+            }
+        )
+    recs.sort(key=lambda r: (r["dataset"], r["i"]))
+    return recs
+
+
+def _score_system(name: str, recs: list[dict]) -> dict:
+    """Score one competitor system, paired against source/human/KLAR."""
+    if not recs:
+        return {"system": name, "n": 0, "note": "no paired outputs found"}
+
+    def mean(field, key="composite"):
+        return float(np.mean([r[field][key] for r in recs]))
+
+    # paired deltas KLAR - competitor (positive => KLAR simpler/higher)
+    d_comp = [r["KLAR"]["composite"] - r["competitor"]["composite"] for r in recs]
+    fl = [
+        (r["KLAR"]["flesch"], r["competitor"]["flesch"])
+        for r in recs
+        if isinstance(r["KLAR"]["flesch"], int | float)
+        and isinstance(r["competitor"]["flesch"], int | float)
+    ]
+    d_fl = [a - b for a, b in fl]
+    sub = lambda r: r["sub"]  # noqa: E731
+
+    return {
+        "system": name,
+        "n": len(recs),
+        "mean_composite": {
+            "source": mean("source"),
+            "competitor": mean("competitor"),
+            "KLAR": mean("KLAR"),
+            "human": mean("human"),
+        },
+        "mean_flesch": {
+            "source": float(
+                np.mean(
+                    [
+                        r["source"]["flesch"]
+                        for r in recs
+                        if isinstance(r["source"]["flesch"], int | float)
+                    ]
+                )
+            ),
+            "competitor": float(np.mean([b for _, b in fl])) if fl else None,
+            "KLAR": float(np.mean([a for a, _ in fl])) if fl else None,
+        },
+        # COMPOSITE comparison (CIRCULAR - flag, do not headline)
+        "KLAR_vs_competitor_composite": {
+            "mean_delta": float(np.mean(d_comp)),
+            "pct_KLAR_higher": 100 * float(np.mean([x > 0 for x in d_comp])),
+            "wilcoxon_p_onesided": wilcoxon_p(d_comp, "greater"),
+            "ci_mean_delta": cluster_bootstrap_ci(
+                recs,
+                lambda rs: float(
+                    np.mean(
+                        [
+                            r["KLAR"]["composite"] - r["competitor"]["composite"]
+                            for r in rs
+                        ]
+                    )
+                ),
+                sub,
+            ),
+            "_caveat": "composite is what KLAR optimises; competitors do not -> favours KLAR",
+        },
+        # FLESCH comparison (INDEPENDENT - this is the one to headline)
+        "KLAR_vs_competitor_flesch": {
+            "n": len(d_fl),
+            "mean_delta": float(np.mean(d_fl)) if d_fl else None,
+            "pct_KLAR_higher": 100 * float(np.mean([x > 0 for x in d_fl]))
+            if d_fl
+            else None,
+            "wilcoxon_p_onesided": wilcoxon_p(d_fl, "greater") if d_fl else None,
+        }
+        if d_fl
+        else {"n": 0},
+        "records": recs,
+    }
+
+
+def main(argv: list[str] | None = None) -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--systems",
+        default=HEADLINE_SYSTEMS,
+        help="comma list of bundle system names, e.g. 'capito' and/or "
+        f"'{HEADLINE_SYSTEMS}'",
+    )
+    ap.add_argument(
+        "--scores",
+        default=str(SCORES),
+        help="path to the text-free competitors score bundle (competitors.jsonl)",
+    )
+    ap.add_argument(
+        "--datasets",
+        default=DEFAULT_DATASETS,
+        help="comma list of bundle `dataset` values to include. Default "
+        f"'{DEFAULT_DATASETS}' (n=514) matches the paper's as-submitted table. "
+        "Pass 'toborek,deplain_web,deplain_apa' for the pooled n=997 variant "
+        "(DEplain-APA pooled in later).",
+    )
+    args = ap.parse_args(argv)
+    OUT.mkdir(parents=True, exist_ok=True)
+
+    datasets = {d.strip() for d in args.datasets.split(",") if d.strip()}
+    rows = [r for r in load_rows(args.scores) if r["dataset"] in datasets]
+    by_item = systems_by_item(rows)
+
+    systems = [s.strip() for s in args.systems.split(",") if s.strip()]
+    scored = [_score_system(s, _build_recs(s, by_item)) for s in systems]
+    scored = [s for s in scored if s.get("n")]
+
+    # BH-FDR across systems on the (independent) Flesch comparison
+    fpv = [
+        s["KLAR_vs_competitor_flesch"].get("wilcoxon_p_onesided") for s in scored
+    ]
+    fpv_ok = [p if isinstance(p, float) else 1.0 for p in fpv]
+    if fpv_ok:
+        adj = bh_fdr(fpv_ok)
+        for s, q in zip(scored, adj, strict=False):
+            s["KLAR_vs_competitor_flesch"]["fdr"] = float(q)
+
+    summary = {
+        "_source": "scored by the closed rule engine (scaled_conf, 20 rules) via the "
+        "text-free bundle scores/competitors.jsonl; "
+        "source/human/KLAR/competitor joined per (dataset, pair_idx)",
+        "_datasets": sorted(datasets),
+        "_caveat": "COMPOSITE comparison is circular (KLAR optimises the rule engine the "
+        "composite measures; competitors do not) -> headline the Flesch comparison.",
+        "systems": [{k: v for k, v in s.items() if k != "records"} for s in scored],
+    }
+    (OUT / "summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+    # ---- report ----
+    for s in scored:
+        mc, mf = s["mean_composite"], s["mean_flesch"]
+        kc = s["KLAR_vs_competitor_composite"]
+        kf = s["KLAR_vs_competitor_flesch"]
+        print(f"\n=== {s['system']}  (n={s['n']}) ===")
+        print(
+            f"  mean composite : source {mc['source']:.3f} | {s['system']} {mc['competitor']:.3f} "
+            f"| KLAR {mc['KLAR']:.3f} | human {mc['human']:.3f}"
+        )
+        if mf.get("competitor") is not None:
+            print(
+                f"  mean Flesch    : source {mf['source']:.1f} | {s['system']} {mf['competitor']:.1f} "
+                f"| KLAR {mf['KLAR']:.1f}"
+            )
+        print(
+            f"  [composite] KLAR−{s['system']} Δ={kc['mean_delta']:+.3f} "
+            f"CI{_f(kc['ci_mean_delta'])}  {kc['pct_KLAR_higher']:.0f}% higher  "
+            f"p={kc['wilcoxon_p_onesided']:.2e}  ⚠️ circular"
+        )
+        if kf.get("n"):
+            print(
+                f"  [Flesch ⟵headline] KLAR−{s['system']} Δ={kf['mean_delta']:+.1f}  "
+                f"{kf['pct_KLAR_higher']:.0f}% higher  p={kf['wilcoxon_p_onesided']:.2e}"
+                + (f"  fdr={kf['fdr']:.2e}" if "fdr" in kf else "")
+            )
+    print(f"\nWrote {OUT}/summary.json")
+    if any(s["system"] == "capito" for s in scored):
+        print(
+            "NOTE: capito is n=3 pilot-only / qualitative, not a powered claim."
+        )
+
+
+def _f(ci) -> str:
+    return f"[{ci[0]:.3f},{ci[1]:.3f}]"
+
+
+if __name__ == "__main__":
+    main()

experiments/rq4_tost.py

@@ -0,0 +1,405 @@
+"""RQ4-TOST - equivalence test on independent Flesch: is KLAR EQUIVALENT to the erlesen
+specialists within a pre-registered +/-5-Flesch margin?
+
+Turns the "no significant difference vs erlesen" non-result (failure to reject is not
+equivalence) into a properly-tested equivalence statement on the readability axis only.
+
+  * Reference system = `KLAR`. Pre-registered equivalence arms = erlesen-leo-7b,
+    erlesen-leo-13b. German4all and elgepa-8b are run too for completeness (expected NOT
+    equivalent, KLAR higher, which is fine; the equivalence claim is only for the two erlesen
+    arms).
+  * Metric: independent Flesch (raw; never the composite, which would be circular here). KLAR
+    and competitor per-doc Flesch are both read straight from the released text-free bundle
+    `scores/competitors.jsonl`, the same file rq4_competitors.py reads, so the numbers match
+    rq4_competitors/summary.json. Included (dataset, i) pairs come from the bundle's own
+    `systems_by_item` grouping. Filtered to `--datasets` (default toborek,deplain_web, n=514,
+    the paper's as-submitted table).
+  * Pairing: delta = KLAR_flesch - competitor_flesch, paired on (dataset, i). Keep only docs
+    where BOTH have a numeric Flesch (drop flesch=None on either side); report n + n_dropped
+    per arm. cluster = subcorpus (`corpus`).
+  * Primary verdict: cluster-bootstrap 90% CI on the mean delta (clustered by subcorpus, 10k
+    resamples, alpha=0.10). Equivalence is concluded for an arm iff the 90% CI lies entirely
+    within [-5, +5]. Also: two one-sided paired-TOST p-values against +/-5 (tost_p = max of
+    the two; BH-FDR across the competitor arms), plus per-arm mean/median/SD delta and Cohen's
+    d.
+
+Self-test gate: before any test, recompute each system's mean Flesch on its both-numeric pool
+and assert it matches rq4_competitors/summary.json `mean_flesch` (KLAR differs per arm because
+the both-numeric subset differs; erlesen-7b approx 83.87, erlesen-13b approx 87.71). On
+mismatch, STOP (do not produce results from a mis-parsed pool).
+
+Run:  python -m experiments.rq4_tost
+      python -m experiments.rq4_tost --datasets toborek,deplain_web,deplain_apa
+  (pure Python/numpy/scipy; reads Flesch from the released text-free bundle; no scorer import.)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+import numpy as np
+from scipy import stats as sps
+
+from experiments.scores_bundle import load_rows, systems_by_item
+from experiments.stats_utils import (
+    bh_fdr,
+    cluster_bootstrap_ci,
+    cohens_d_paired,
+)
+
+# ---------------------------------------------------------------- paths / config
+RESULTS = Path("results")
+RQ4_COMP = RESULTS / "rq4_competitors"
+SUMMARY_PATH = RQ4_COMP / "summary.json"
+SCORES_PATH = Path("scores") / "competitors.jsonl"
+OUT_PATH = RESULTS / "rq4_tost.json"
+DEFAULT_DATASETS = "toborek,deplain_web"
+
+REFERENCE_SYSTEM = "KLAR"
+# Pre-registered equivalence arms first, then the completeness arms.
+EQUIVALENCE_ARMS = ["erlesen-leo-7b", "erlesen-leo-13b"]
+COMPLETENESS_ARMS = ["German4all", "elgepa-8b"]
+COMPETITORS = EQUIVALENCE_ARMS + COMPLETENESS_ARMS
+
+MARGIN = 5.0  # pre-registered SESOI, ±5 Flesch points (fixed before the run)
+N_BOOT = 10000
+SEED = 0
+CI_ALPHA = 0.10  # 90% CI for TOST (α=0.05 per side; cluster_bootstrap_ci default is 0.05 → 95%)
+
+CALIBRATION_NOTE = (
+    "Independent Flesch (raw readability index) for both KT and competitor, read straight "
+    "from readability['flesch'] in the released text-free bundle scores/competitors.jsonl "
+    "- the SAME bundle rq4_competitors.py reads to produce rq4_competitors/summary.json. "
+    "NEVER the composite (circular on this axis)."
+)
+
+
+# ---------------------------------------------------------------- loaders
+def _build_records(
+    competitor: str, by_item: dict[tuple[str, int], dict[str, dict]]
+) -> tuple[list[dict], dict]:
+    """Build paired KT-vs-competitor Flesch records for one arm, from the released bundle.
+
+    Mirrors rq4_competitors._build_recs's join: a (dataset, i) item is kept only if it has
+    rows for both `KLAR` and this competitor system. Flesch for both sides comes
+    straight from the bundle (`scores/competitors.jsonl`, the same file rq4_competitors.py
+    reads).
+
+    Returns (records, diag) where each record is {dataset, i, corpus, kt_flesch, comp_flesch}
+    over ALL joined docs (Flesch may be None on either side; filtered later), and diag carries
+    the joined-row count and how many items had no paired KLAR row.
+    """
+    records: list[dict] = []
+    n_no_kt_join = 0
+    for (dataset, i), systems in by_item.items():
+        if competitor not in systems:
+            continue
+        if "KLAR" not in systems:
+            n_no_kt_join += 1
+            continue
+        comp_row = systems[competitor]
+        kt_row = systems["KLAR"]
+        records.append(
+            {
+                "dataset": dataset,
+                "i": i,
+                "corpus": comp_row.get("sub") or "?",
+                "kt_flesch": kt_row["readability"]["flesch"],
+                "comp_flesch": comp_row["readability"]["flesch"],
+            }
+        )
+    records.sort(key=lambda r: (r["dataset"], r["i"]))
+    diag = {"n_joined_rows": len(records), "n_rows_no_kt_source_join": n_no_kt_join}
+    return records, diag
+
+
+def _paired(records: list[dict]) -> tuple[list[dict], int]:
+    """Keep only docs where BOTH KT and competitor have a numeric Flesch.
+
+    Returns (pairs, n_dropped). Each pair: {dataset, i, corpus, delta, kt, comp}.
+    delta = KT − competitor (>0 ⇒ KLAR more readable on Flesch).
+    """
+    pairs: list[dict] = []
+    n_dropped = 0
+    for r in records:
+        kf, cf = r["kt_flesch"], r["comp_flesch"]
+        if isinstance(kf, int | float) and isinstance(cf, int | float):
+            pairs.append(
+                {
+                    "dataset": r["dataset"],
+                    "i": r["i"],
+                    "corpus": r["corpus"],
+                    "kt": float(kf),
+                    "comp": float(cf),
+                    "delta": float(kf) - float(cf),
+                }
+            )
+        else:
+            n_dropped += 1
+    return pairs, n_dropped
+
+
+# ---------------------------------------------------------------- TOST
+def _tost_paired(deltas: np.ndarray, margin: float) -> tuple[float, float]:
+    """Two one-sided paired t-tests of the mean delta against ±margin.
+
+    H0_lower: mean(delta) <= -margin   vs  H1_lower: mean(delta) > -margin
+    H0_upper: mean(delta) >= +margin   vs  H1_upper: mean(delta) < +margin
+    Returns (p_lower, p_upper). Equivalence is supported when BOTH are small
+    (TOST p = max(p_lower, p_upper)). Hand-rolled with scipy.stats.t because
+    statsmodels.ttost_paired is not installed in this env.
+    """
+    n = len(deltas)
+    mean = float(deltas.mean())
+    sd = float(deltas.std(ddof=1)) if n > 1 else float("nan")
+    if not (n > 1) or not (sd > 0):
+        return float("nan"), float("nan")
+    se = sd / np.sqrt(n)
+    df = n - 1
+    # lower test: t = (mean - (-margin)) / se, one-sided upper tail (mean > -margin)
+    t_lower = (mean + margin) / se
+    p_lower = float(sps.t.sf(t_lower, df))
+    # upper test: t = (mean - (+margin)) / se, one-sided lower tail (mean < +margin)
+    t_upper = (mean - margin) / se
+    p_upper = float(sps.t.cdf(t_upper, df))
+    return p_lower, p_upper
+
+
+def _mean_delta(recs: list[dict]) -> float:
+    return float(np.mean([r["delta"] for r in recs]))
+
+
+def _analyze(pairs: list[dict], n_dropped: int) -> dict:
+    arr = np.asarray([p["delta"] for p in pairs], dtype="float64")
+    boot_lo, boot_hi = cluster_bootstrap_ci(
+        pairs,
+        statfn=_mean_delta,
+        cluster_key=lambda r: r["corpus"],
+        n=N_BOOT,
+        seed=SEED,
+        alpha=CI_ALPHA,
+    )
+    p_lower, p_upper = _tost_paired(arr, MARGIN)
+    tost_p = (
+        float(max(p_lower, p_upper))
+        if not (np.isnan(p_lower) or np.isnan(p_upper))
+        else float("nan")
+    )
+    within = bool(boot_lo >= -MARGIN and boot_hi <= MARGIN)
+    return {
+        "n": len(pairs),
+        "n_dropped": n_dropped,
+        "n_clusters": len({p["corpus"] for p in pairs}),
+        "mean_delta": float(arr.mean()),
+        "median_delta": float(np.median(arr)),
+        "sd": float(arr.std(ddof=1)) if len(arr) > 1 else float("nan"),
+        "cohens_d": cohens_d_paired(arr.tolist()),
+        "cluster_boot_90ci": [boot_lo, boot_hi],
+        "tost_p_lower": p_lower,
+        "tost_p_upper": p_upper,
+        "tost_p": tost_p,
+        "within_margin": within,
+        "margin": MARGIN,
+    }
+
+
+# ---------------------------------------------------------------- self-test
+def _self_test(records_by_comp: dict[str, list[dict]], datasets: set[str]) -> dict:
+    """Reconcile recomputed per-system MEAN Flesch (on the both-numeric pool) vs summary.json.
+
+    rq4_competitors/summary.json stores, per arm, mean_flesch.{KLAR, competitor} computed over
+    the both-numeric paired subset (the `fl` list in rq4_competitors). KT's mean therefore differs
+    per arm. We recompute on exactly that subset and assert agreement.
+    """
+    summary = json.loads(SUMMARY_PATH.read_text(encoding="utf-8"))
+    exp = {s["system"]: s.get("mean_flesch", {}) for s in summary["systems"]}
+
+    print(
+        "Self-test - recomputed mean Flesch (both-numeric pool) vs rq4_competitors/summary.json:"
+    )
+    ok = True
+    reconciled: dict[str, dict] = {}
+    for comp in COMPETITORS:
+        pairs, _ = _paired(records_by_comp[comp])
+        kt_got = float(np.mean([p["kt"] for p in pairs])) if pairs else float("nan")
+        comp_got = float(np.mean([p["comp"] for p in pairs])) if pairs else float("nan")
+        kt_exp = exp.get(comp, {}).get("KLAR")
+        comp_exp = exp.get(comp, {}).get("competitor")
+        kt_tag = (
+            "n/a"
+            if kt_exp is None
+            else ("OK" if abs(kt_got - kt_exp) < 0.05 else "MISMATCH")
+        )
+        comp_tag = (
+            "n/a"
+            if comp_exp is None
+            else ("OK" if abs(comp_got - comp_exp) < 0.05 else "MISMATCH")
+        )
+        if (kt_exp is not None and kt_tag != "OK") or (
+            comp_exp is not None and comp_tag != "OK"
+        ):
+            ok = False
+        print(
+            f"  {comp:18s} n={len(pairs):4d} | "
+            f"KT got={kt_got:7.3f} summary={kt_exp} [{kt_tag}] | "
+            f"{comp} got={comp_got:7.3f} summary={comp_exp} [{comp_tag}]"
+        )
+        reconciled[comp] = {
+            "n_both_numeric": len(pairs),
+            "kt_mean_flesch_recomputed": kt_got,
+            "kt_mean_flesch_summary": kt_exp,
+            "competitor_mean_flesch_recomputed": comp_got,
+            "competitor_mean_flesch_summary": comp_exp,
+            "kt_tag": kt_tag,
+            "competitor_tag": comp_tag,
+        }
+    assert ok, (
+        "recomputed mean Flesch does not match rq4_competitors/summary.json - the pool/parse "
+        "is wrong; STOP (do not produce results from a mis-parsed pool)."
+    )
+    # explicit pre-reg anchors: only valid for the default n=514 pool (toborek,deplain_web),
+    # the paper's as-submitted table. Other --datasets scopes have different competitor means,
+    # so they rely on the summary.json reconciliation above and skip these fixed anchors.
+    if datasets == {"toborek", "deplain_web"}:
+        e7b = reconciled["erlesen-leo-7b"]["competitor_mean_flesch_recomputed"]
+        e13b = reconciled["erlesen-leo-13b"]["competitor_mean_flesch_recomputed"]
+        assert abs(e7b - 83.87) < 0.05, e7b
+        assert abs(e13b - 87.71) < 0.05, e13b
+        print(
+            f"  anchors erlesen-leo-7b={e7b:.2f} approx 83.87 and "
+            f"erlesen-leo-13b={e13b:.2f} approx 87.71 confirmed.\n"
+        )
+    reconciled["_passed"] = True
+    return reconciled
+
+
+# ---------------------------------------------------------------- main
+def _git_sha() -> str:
+    try:
+        return subprocess.check_output(
+            ["git", "rev-parse", "HEAD"], text=True, stderr=subprocess.DEVNULL
+        ).strip()
+    except Exception:  # noqa: BLE001
+        return "unknown"
+
+
+def main(argv: list[str] | None = None) -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--datasets",
+        default=DEFAULT_DATASETS,
+        help="comma list of bundle `dataset` values to include. Default "
+        f"'{DEFAULT_DATASETS}' (n=514) matches rq4_competitors.py's default and the "
+        "paper's as-submitted table. Pass 'toborek,deplain_web,deplain_apa' for the "
+        "pooled n=997 variant (DEplain-APA pooled in later). Must match the "
+        "rq4_competitors.py run that produced SUMMARY_PATH, or the self-test gate fails.",
+    )
+    args = ap.parse_args(argv)
+    datasets = {d.strip() for d in args.datasets.split(",") if d.strip()}
+
+    rows = [r for r in load_rows(SCORES_PATH) if r["dataset"] in datasets]
+    by_item = systems_by_item(rows)
+
+    records_by_comp: dict[str, list[dict]] = {}
+    diag_by_comp: dict[str, dict] = {}
+    for comp in COMPETITORS:
+        recs, diag = _build_records(comp, by_item)
+        records_by_comp[comp] = recs
+        diag_by_comp[comp] = diag
+
+    # ---- MANDATORY self-test gate ----
+    reconciled = _self_test(records_by_comp, datasets)
+
+    # ---- per-arm TOST ----
+    by_competitor: dict[str, dict] = {}
+    for comp in COMPETITORS:
+        pairs, n_dropped = _paired(records_by_comp[comp])
+        res = _analyze(pairs, n_dropped)
+        res["_diag"] = {
+            **diag_by_comp[comp],
+            "arm_role": "equivalence" if comp in EQUIVALENCE_ARMS else "completeness",
+        }
+        by_competitor[comp] = res
+
+    # ---- BH-FDR across the competitor arms on tost_p (max of the two one-sided) ----
+    arms = list(by_competitor.keys())
+    p_for_fdr = [by_competitor[c]["tost_p"] for c in arms]
+    p_for_fdr_clean = [p if not np.isnan(p) else 1.0 for p in p_for_fdr]
+    p_fdr = bh_fdr(p_for_fdr_clean)
+    for c, q in zip(arms, p_fdr, strict=True):
+        by_competitor[c]["tost_p_fdr"] = float(q)
+
+    payload = {
+        "_experiment": "RQ4-TOST",
+        "_source": {
+            "kt_and_competitor_flesch": str(SCORES_PATH)
+            + " (text-free bundle, same file rq4_competitors.py reads)",
+            "summary_reconciled_against": str(SUMMARY_PATH),
+            "datasets": sorted(datasets),
+            "git_sha": _git_sha(),
+        },
+        "_params": {
+            "reference_system": REFERENCE_SYSTEM,
+            "equivalence_arms": EQUIVALENCE_ARMS,
+            "completeness_arms": COMPLETENESS_ARMS,
+            "margin": MARGIN,
+            "n_boot": N_BOOT,
+            "seed": SEED,
+            "ci_alpha": CI_ALPHA,
+            "ci_level": "90% (alpha=0.10; α=0.05 per side, standard TOST)",
+            "calibration_note": CALIBRATION_NOTE,
+        },
+        "_method": {
+            "direction": "delta = KT_flesch - competitor_flesch, paired per (dataset, i); "
+            ">0 ⇒ KLAR higher Flesch (more readable on this index).",
+            "pairing": "keep docs where BOTH KT and competitor have a NUMERIC Flesch; "
+            "drop flesch=None on either side (n_dropped reported per arm).",
+            "primary_verdict": "cluster-bootstrap 90% CI on the MEAN delta (cluster=corpus, "
+            f"{N_BOOT} resamples, seed={SEED}); equivalence iff the CI lies ENTIRELY within "
+            f"[-{MARGIN}, +{MARGIN}].",
+            "tost": "two one-sided paired t-tests vs ±margin (hand-rolled, scipy.stats.t; "
+            "statsmodels.ttost_paired not installed); tost_p = max(p_lower, p_upper); "
+            "BH-FDR across the competitor arms.",
+            "equivalence_claim_scope": "pre-registered for the two erlesen arms ONLY; "
+            "German4all/elgepa-8b are completeness arms (expected NOT equivalent).",
+        },
+        "_self_test": reconciled,
+        "by_competitor": by_competitor,
+    }
+
+    OUT_PATH.parent.mkdir(parents=True, exist_ok=True)
+    OUT_PATH.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+    # ---- console report ----
+    print(
+        f"TOST equivalence on independent Flesch - margin ±{MARGIN}, 90% cluster-boot CI"
+    )
+    print("direction: delta = KT − competitor (>0 ⇒ KT higher Flesch)\n")
+    hdr = (
+        f"{'competitor':18s} {'role':12s} {'n':>4s} {'drop':>5s} "
+        f"{'meanΔ':>7s} {'medΔ':>7s} {'sd':>6s} {'d':>6s} "
+        f"{'90% CI':>18s} {'p_lo':>9s} {'p_up':>9s} {'tost_p':>9s} {'p_fdr':>9s} {'within±5':>9s}"
+    )
+    print(hdr)
+    print("-" * len(hdr))
+    for comp in COMPETITORS:
+        b = by_competitor[comp]
+        ci = b["cluster_boot_90ci"]
+        print(
+            f"{comp:18s} {b['_diag']['arm_role']:12s} {b['n']:4d} {b['n_dropped']:5d} "
+            f"{b['mean_delta']:+7.2f} {b['median_delta']:+7.2f} {b['sd']:6.2f} "
+            f"{b['cohens_d']:+6.2f} "
+            f"[{ci[0]:+6.2f},{ci[1]:+6.2f}] "
+            f"{b['tost_p_lower']:9.2e} {b['tost_p_upper']:9.2e} "
+            f"{b['tost_p']:9.2e} {b['tost_p_fdr']:9.2e} {str(b['within_margin']):>9s}"
+        )
+    print(f"\nWrote {OUT_PATH}")
+
+
+if __name__ == "__main__":
+    main()

experiments/scores_bundle.py

@@ -0,0 +1,124 @@
+"""Text-free per-document score bundle - the released reproducibility artifact.
+
+One JSONL row per document (each eval pair contributes two: original + simplified).
+A row holds ONLY numbers + opaque metadata - no source or simplified text - so the
+analysis scripts can reproduce every paper table without the restricted corpora and
+without the closed scorer. This is the "per-document score tables" the paper's
+Reproducibility paragraph (§8) commits to releasing.
+
+This module imports no scorer code. It sits on the released side: the producing side
+imports the closed scorer to fill the rows; this reader/writer only reshapes and
+serialises.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SCHEMA = 1
+
+
+def make_row(
+    *,
+    item_id: str,
+    dataset: str,
+    pair_idx: int,
+    side: str,  # "orig" | "simp"
+    sub: str,  # source subcorpus label (feeds keep() + per-subcorpus stats)
+    register: str | None,  # source register label, or None
+    per_rule: dict[str, dict],  # {rule: {raw, scaled, w}}: the 20 calibrated rules
+    composite: dict,  # {raw, scaled, scaled_conf}
+    readability: dict,  # {flesch, lix, wiener_sachtextformel} raw, sign-corrected
+    n_words: int,
+    meta: dict | None = None,  # non-text source fields (level, article_id, split, …)
+) -> dict:
+    """Build one text-free bundle row. Keyword-only so field identity can't drift.
+
+    `meta` passes through the source record's non-text scalar fields (e.g. apa_lha's
+    `level`/`article_id` that rq3_graded groups on) so every analysis can re-key off the
+    bundle. The producer must strip all text fields before populating it."""
+    return {
+        "schema": SCHEMA,
+        "item_id": item_id,
+        "dataset": dataset,
+        "pair_idx": pair_idx,
+        "side": side,
+        "sub": sub,
+        "register": register,
+        "per_rule": per_rule,
+        "composite": composite,
+        "readability": readability,
+        "n_words": n_words,
+        "meta": meta or {},
+    }
+
+
+def write_bundle(path: str | Path, rows: list[dict]) -> None:
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    with p.open("w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+
+def load_rows(path: str | Path) -> list[dict]:
+    text = Path(path).read_text(encoding="utf-8")
+    return [json.loads(line) for line in text.splitlines() if line.strip()]
+
+
+def pairs_by_idx(rows: list[dict]) -> list[tuple[dict, dict]]:
+    """Group rows into (orig_row, simp_row) by pair_idx, in ascending pair_idx order
+    (the order export wrote them, i.e. the source-corpus order the live path iterates)."""
+    by: dict[int, dict[str, dict]] = {}
+    for r in rows:
+        by.setdefault(r["pair_idx"], {})[r["side"]] = r
+    out = []
+    for idx in sorted(by):
+        d = by[idx]
+        if "orig" in d and "simp" in d:
+            out.append((d["orig"], d["simp"]))
+    return out
+
+
+def kept_pairs(rows: list[dict], min_words: int) -> list[tuple[dict, dict]]:
+    """(orig_row, simp_row) pairs after the paper's keep() + min-words filters, applied
+    from bundle metadata alone - the released equivalent of the live scoring loop's
+    corpus filtering. Shared by every analysis that reads the bundle."""
+    from experiments.eval_filters import keep
+
+    return [
+        (orig, simp)
+        for orig, simp in pairs_by_idx(rows)
+        if keep({"corpus": orig["sub"]})
+        and min(orig["n_words"], simp["n_words"]) >= min_words
+    ]
+
+
+def make_system_row(
+    *, dataset, pair_idx, system, composite_scaled_conf, flesch, n_words, sub, meta=None
+):
+    """One row for a multi-system comparison bundle (RQ4 competitors): source/human/
+    KLAR/competitor-model outputs scored the same way, joined by (dataset, pair_idx,
+    system) instead of the orig/simp `side` the pair bundle uses."""
+    return {
+        "schema": SCHEMA,
+        "kind": "system",
+        "item_id": f"{dataset}:{pair_idx}:{system}",
+        "dataset": dataset,
+        "pair_idx": pair_idx,
+        "system": system,
+        "composite": {"scaled_conf": composite_scaled_conf},
+        "readability": {"flesch": flesch},
+        "n_words": n_words,
+        "sub": sub,
+        "meta": meta or {},
+    }
+
+
+def systems_by_item(rows: list[dict]) -> dict[tuple[str, int], dict[str, dict]]:
+    """{(dataset, pair_idx): {system: row}} - group multi-system competitor rows."""
+    by: dict[tuple[str, int], dict[str, dict]] = {}
+    for r in rows:
+        by.setdefault((r["dataset"], r["pair_idx"]), {})[r["system"]] = r
+    return by

experiments/stats_utils.py

@@ -0,0 +1,91 @@
+"""Statistical primitives for the evaluation experiments.
+
+Inferential layer: paired significance (Wilcoxon signed-rank), cluster-aware bootstrap
+CIs, Benjamini-Hochberg FDR, and AUC (+ bootstrap CI on AUC differences for the ablation).
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Callable, Sequence
+
+import numpy as np
+from scipy import stats as sps
+
+
+def auc(pos: Sequence[float], neg: Sequence[float]) -> float:
+    """AUC = P(random pos > random neg), via Mann-Whitney U (ties = 0.5)."""
+    pos = np.asarray(pos, float)
+    neg = np.asarray(neg, float)
+    if len(pos) == 0 or len(neg) == 0:
+        return float("nan")
+    ranks = sps.rankdata(np.concatenate([pos, neg]))
+    u = ranks[: len(pos)].sum() - len(pos) * (len(pos) + 1) / 2
+    return float(u / (len(pos) * len(neg)))
+
+
+def wilcoxon_p(deltas: Sequence[float], alternative: str = "greater") -> float:
+    """Wilcoxon signed-rank p-value on paired deltas (drops zeros)."""
+    d = np.asarray(deltas, float)
+    d = d[d != 0]
+    if len(d) < 1:
+        return float("nan")
+    try:
+        return float(sps.wilcoxon(d, alternative=alternative).pvalue)
+    except ValueError:
+        return float("nan")
+
+
+def cohens_d_paired(deltas: Sequence[float]) -> float:
+    d = np.asarray(deltas, float)
+    sd = d.std(ddof=0)
+    return float(d.mean() / sd) if sd > 0 else float("nan")
+
+
+def bh_fdr(pvals: Sequence[float]) -> np.ndarray:
+    """Benjamini-Hochberg adjusted p-values."""
+    p = np.asarray(pvals, float)
+    n = len(p)
+    order = np.argsort(p)
+    ranked = p[order] * n / np.arange(1, n + 1)
+    ranked = np.minimum.accumulate(ranked[::-1])[::-1]
+    adj = np.empty(n)
+    adj[order] = np.clip(ranked, 0, 1)
+    return adj
+
+
+def cluster_bootstrap_ci(
+    records: Sequence[dict],
+    statfn: Callable[[list[dict]], float],
+    cluster_key: Callable[[dict], str] | None = None,
+    n: int = 2000,
+    seed: int = 0,
+    alpha: float = 0.05,
+) -> tuple[float, float]:
+    """Percentile CI for `statfn`. If cluster_key is given, resample whole clusters
+    (accounts for non-independence within a subcorpus); else resample records."""
+    rng = np.random.default_rng(seed)
+    recs = list(records)
+    boot: list[float] = []
+    keys: list[str] = []
+    if cluster_key is not None:
+        groups: dict[str, list[dict]] = defaultdict(list)
+        for r in recs:
+            groups[cluster_key(r)].append(r)
+        keys = list(groups)
+        if len(keys) < 2:  # single cluster → cluster bootstrap is degenerate
+            cluster_key = None
+    if cluster_key is not None:
+        for _ in range(n):
+            chosen = rng.integers(0, len(keys), size=len(keys))
+            sample: list[dict] = []
+            for ci in chosen:
+                sample.extend(groups[keys[ci]])
+            boot.append(statfn(sample))
+    else:
+        m = len(recs)
+        for _ in range(n):
+            idx = rng.integers(0, m, size=m)
+            boot.append(statfn([recs[i] for i in idx]))
+    lo, hi = np.nanpercentile(boot, [100 * alpha / 2, 100 * (1 - alpha / 2)])
+    return float(lo), float(hi)

requirements.txt

@@ -0,0 +1,3 @@
+numpy
+scipy
+matplotlib

scores/apa_lha.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dade224b1b918fa748107e194c360ef5668352a149fc11d5ff87018ce25f7738
+size 14741268