Remove annotation-scheme leakage from model-facing columns

Sphragis merges seven annotation projects whose author inventories do not
overlap, so every convention that separates the projects also separates the
authors. A classifier seeing annotation markup and no Greek at all reached
63.4% accuracy and 45.3 macro-F1 on the 17-way sentence_1 task against a
14.6% baseline, and single rules were near-deterministic: no PUNCT token
identified Herodotus at 99.6% precision over 83% of his sentences, and an
empty MISC column separated the Iliad from the Odyssey at 83.5%.

Every published column is now reduced to one shared representation:

- MISC is cleared; NativeRel, NativeHead and HeadRepair move to a new
native_syntax audit column, keyed by published and source token index.
- Editorial punctuation tokens are removed and trees re-indexed, because UD
PROIEL does not tokenize punctuation at all.
- Elision is written as a combining comma by AGDT and UD Perseus, as three
different apostrophes within Gorman, and as U+2019 by Pedalion and PROIEL;
all spellings now reduce to the same truncated form.
- Word forms, lemmas, text and metre syllables are lowercased with
grc_utils.lower_grc.
- UPOS is derived from the normalized XPOS, and UPOS, XPOS, FEATS and DEPREL
are collapsed onto the inventories every project shares.
- The # text comment is dropped; the text column already carried it.

This removes the deterministic tells but not the confound: the projects
disagree about tree shape, not only about labels. Markup-only attribution
falls to 52.7% / 34.0 and treebank recoverability to 82.2%.

The source_held_out_* configurations are the actual remedy. Each author's
second-largest source project is held out entirely as its validation and
test data, so a model that recognizes annotators is penalized rather than
rewarded. Eleven authors qualify. There markup-only attribution falls to
22.0% / 11.2 against an 11.9% baseline, and treebank recoverability to 35.3%.

scripts/audit_leakage.py measures all of this into metadata/leakage_report.json
and runs in the rebuild, so the floor a real model must clear is published
rather than assumed.

Two upstream defects surfaced while validating, both previously silent:
some AGDT and Pedalion trees have their tag column offset against their
forms, so punctuation is now decided from the form rather than the tag; and
2,092 Sphragis Metre units hold more than one sentence block, which are now
finalized separately instead of being merged into one malformed tree.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

README.md

@@ -43,6 +43,38 @@ configs:
     path: data/sentence_100/validation-*
   - split: test
     path: data/sentence_100/test-*
+- config_name: source_held_out_1
+  data_files:
+  - split: train
+    path: data/source_held_out_1/train-*
+  - split: validation
+    path: data/source_held_out_1/validation-*
+  - split: test
+    path: data/source_held_out_1/test-*
+- config_name: source_held_out_10
+  data_files:
+  - split: train
+    path: data/source_held_out_10/train-*
+  - split: validation
+    path: data/source_held_out_10/validation-*
+  - split: test
+    path: data/source_held_out_10/test-*
+- config_name: source_held_out_50
+  data_files:
+  - split: train
+    path: data/source_held_out_50/train-*
+  - split: validation
+    path: data/source_held_out_50/validation-*
+  - split: test
+    path: data/source_held_out_50/test-*
+- config_name: source_held_out_100
+  data_files:
+  - split: train
+    path: data/source_held_out_100/train-*
+  - split: validation
+    path: data/source_held_out_100/validation-*
+  - split: test
+    path: data/source_held_out_100/test-*
 ---
 
 # Sphragis
@@ -66,8 +98,17 @@ provenance preserved.
 
 ## Tasks
 
-There are four task sizes. Prose and verse sentences share one closed-set
-authorship problem; the `genre` column preserves their source representation.
+There are four task sizes on each of two tracks. Prose and verse sentences
+share one closed-set authorship problem; the `genre` column preserves their
+source representation.
+
+The **main track** (`sentence_*`) splits rows randomly within author and work.
+The **source-held-out track** (`source_held_out_*`) splits them by annotation
+project: each author's validation and test sentences come from a treebank that
+supplies none of that author's training sentences. See
+[Source-held-out track](#source-held-out-track) for why this exists and
+[Model-facing representation](#model-facing-representation) for what was done
+to the main track in consequence.
 
 ## Configurations
 
@@ -77,6 +118,15 @@ authorship problem; the `genre` column preserves their source representation.
 | `sentence_10` | 17 | 10-sentence chunk | 4,330 | 480 | 480 |
 | `sentence_50` | 17 | 50-sentence chunk | 866 | 96 | 96 |
 | `sentence_100` | 17 | 100-sentence chunk | 433 | 48 | 48 |
+| `source_held_out_1` | 11 | sentence | 25,100 | 4,200 | 4,200 |
+| `source_held_out_10` | 11 | 10-sentence chunk | 2,510 | 420 | 420 |
+| `source_held_out_50` | 11 | 50-sentence chunk | 502 | 84 | 84 |
+| `source_held_out_100` | 11 | 100-sentence chunk | 251 | 42 | 42 |
+
+The `source_held_out_*` configurations use the same rows, the same chunk sizes
+and the same 100-row bottleneck, over the eleven authors that more than one
+project annotates. Two of them, Hesiod and Lucian, do not reach the main
+track's threshold under random splitting but do under this arrangement.
 
 The suffix gives the chunk size in every split. `_100` defines one shared
 source corpus for all four tasks: an author is retained
@@ -141,16 +191,49 @@ multiples of 100 per author. This makes the
 published source-row ratio slightly different from the initial 80/10/10 split.
 A stricter work-held-out evaluation can be added as a later track.
 
+### Source-held-out track
+
+Sphragis merges seven annotation projects, and those projects do not overlap in
+authors. UD PROIEL contributes Herodotus and nobody else; Pedalion contributes
+Aristophanes and Procopius; the *Odyssey* is entirely AGDT while most of the
+*Iliad* is UD Perseus. Any convention that distinguishes the projects therefore
+also distinguishes the authors, and a model can score well on the main track by
+recognizing the annotator instead of the writer.
+
+The `source_held_out_*` configurations remove that possibility by construction.
+For each author, the **second-largest** source project is held out entirely:
+its sentences become that author's validation and test data, split evenly, and
+every other project supplies training. An author is retained only when the
+held-out project yields at least 100 validation and 100 test rows and at least
+100 training rows remain. A model that has learned to recognize annotators is
+actively penalized here, because every author arrives at evaluation in a scheme
+it was never trained in.
+
+Which project is held out per author, and the row counts that follow, are
+recorded under `source_held_out_track` in
+[`metadata/build_report.json`](metadata/build_report.json). The
+`held_out_source` column repeats it on every row.
+
+This track is the benchmark's answer to the confound. The normalization
+described below removes the parts of the leak that are indefensible on their
+own terms, but it cannot remove all of it: projects genuinely disagree about
+tree shape, and no relabelling can normalize that away. Scores on the two
+tracks are not comparable, and the gap between them is the interesting number.
+
 ## Principal columns
 
 All configurations contain:
 
 - `id`, `author`, `work`, `work_id`, `genre`, `text`;
 - `conllu`, `cts_urn`, `passage`, `treebank_source`;
+- `native_syntax`: JSON audit record of the original relation, head and any
+  head repair for every token whose source project used a non-UD scheme;
 - `source_records`: JSON containing every contributing upstream record,
   revision, URL, license, annotation provenance and syntax scheme;
 - `licenses`, `dedup_key`, and `split`.
 
+The `source_held_out_*` configurations add `held_out_source`.
+
 `text` is always a JSON list of strings. Atomic `_1` rows contain one string;
 every split of `_10`, `_50`, and `_100` contains exactly 10, 50, or 100 separate sentence
 strings. No whitespace separator is used to encode unit boundaries.
@@ -170,34 +253,81 @@ All sentence rows share one schema. There are no metrical, scanned-line, or
 external-alignment columns. `genre` has exactly two values: `prose` and
 `verse`.
 
-## Dependency representation
-
-Existing UD data is retained verbatim. Native AGDT/Arethusa trees are
-serialized as CoNLL-U while preserving heads. Their dependency relations are
-conservatively mapped to the Universal Dependencies v2 inventory; opaque
-source-specific categories fall back to `dep`. The lossless original
-`NativeRel` and `NativeHead` values remain in MISC for audit and future mapping
-improvements. Repairs required after removing artificial ellipsis nodes—or to
-break an upstream beta self-loop/cycle—are explicitly marked `HeadRepair=Yes`.
-
-XPOS is normalized across every source to the nine-position Ancient Greek
-AGDT/Perseus tag convention. Existing valid positional tags are retained;
+## Model-facing representation
+
+Every published `conllu` document and every `text` unit is reduced to one
+scheme-neutral representation, so that no category boundary the source projects
+disagree about can be used as an authorship feature.
+
+**No comments.** CoNLL-U documents contain token rows only. The `# text`
+comment was removed in favour of the dedicated `text` column, which already
+carried the same string; comments carrying `sent_id`, `source`, `cts`,
+`passage` or `newdoc id` had already been stripped.
+
+**No punctuation.** Editorial punctuation tokens are removed from the trees and
+re-indexed, and any dependent hanging from one is re-attached to its nearest
+surviving ancestor. Punctuation is likewise removed from `text`. UD PROIEL does
+not tokenize punctuation at all, so its absence alone identified its single
+author.
+
+**Lowercase throughout.** Word forms, lemmas and `text` are lowercased with
+[`grc_utils.lower_grc`](https://pypi.org/project/grc-utils/), which handles the
+precomposed polytonic letters correctly. Capitalization marked sentence
+openings and proper nouns inconsistently between projects and editions.
+
+**Empty MISC.** The MISC column is `_` on every token. `NativeRel`,
+`NativeHead` and `HeadRepair` sat on every token of the natively converted
+projects and on none of the UD ones, and `SpaceAfter` occurred in UD Perseus
+alone. They now live in the `native_syntax` column, which records the source
+relation, source head and any head repair per token, keyed by both the
+published token index (`i`) and the source document's own numbering (`src`).
+
+**Shared inventories.** UPOS is derived from the normalized XPOS so both
+columns express one scheme, and the categories the projects disagree about are
+merged:
+
+| Column | Published inventory | Merged because |
+|---|---|---|
+| UPOS | `NOUN VERB ADJ PRON ADV ADP NUM INTJ X` | `PROPN` is PROIEL-only; `AUX` is UD-only; δέ is `PART` in AGDT, `ADV` in Gorman and `CCONJ` in UD Perseus; the article is `DET` in UD and a pronoun in the AGDT lineage |
+| DEPREL | `root nsubj obj ccomp obl nmod advmod case conj appos vocative discourse dep` | `cc`, `cop` and `aux` are never produced by the native conversions; `iobj` is UD Perseus only; subtypes such as `nsubj:pass` and `obl:arg` are PROIEL only; the two conversions of the same AGDT trees split attribution between `amod`, `nmod` and `det` |
+| FEATS | `Case Degree Gender Mood Number Person Tense Voice` | `VerbForm` is absent from every native conversion and already carried by XPOS position 5; `PronType`, `Definite`, `Polarity`, `Poss` and `Reflex` occur in one project only |
+| XPOS | nine positions, part of speech in `n v a p d r m i x` | same merges as UPOS, applied to position 1 |
+
+XPOS positions 2–9 are unchanged: the nine-position AGDT/Perseus normalization
+already levelled them across sources, and they are the least source-dependent
+signal in the dataset. Existing valid positional tags are retained;
 incompatible source-specific tags are reconstructed from UPOS and FEATS, with
-unavailable distinctions represented by `-`. UPOS and FEATS remain the
-canonical UD fields.
+unavailable distinctions represented by `-`.
+
+Native AGDT/Arethusa trees are serialized as CoNLL-U while preserving heads.
+Their dependency relations are conservatively mapped to Universal Dependencies
+v2 before the shared inventory is applied; opaque source-specific categories
+fall back to `dep`. Repairs required after removing artificial ellipsis
+nodes—or to break an upstream beta self-loop/cycle—are recorded as
+`repair` in `native_syntax`.
 
 Every distinct published `conllu` document is loaded during testing with the
-[official CoNLL 2018 shared-task `load_conllu` parser](https://github.com/CoNLL-UD-2018/UDPipe-Future/blob/master/conll18_ud_eval.py).
-This checks sentence
+[official CoNLL 2018 shared-task `load_conllu` parser](https://github.com/CoNLL-UD-2018/UDPipe-Future/blob/master/conll18_ud_eval.py),
+and separately checked against every invariant above. This checks sentence
 termination, ten-column structure, token IDs, heads, roots and dependency
-cycles across all configurations.
+cycles across all configurations, and that the CoNLL-U forms reconstruct the
+`text` column exactly.
+
+### Residual leakage
+
+The normalization above removes the deterministic tells. It does not remove the
+confound, and it was never going to: the projects disagree about tree shape
+itself, not only about labels. AGDT-lineage trees mark `conj` on roughly 14% of
+tokens where UD Perseus marks 4% *of the same Iliad*, and no relabelling
+normalizes a genuine analytic disagreement.
 
-To prevent authorship-label leakage, model-facing `conllu` values retain only
-the non-identifying `# text = ...` comment. Comments carrying `sent_id`,
-`source`, `cts`, `passage`, or `newdoc id` are removed. The same information
-remains available for audit in the dataset's dedicated provenance columns.
-Token-level MISC identifiers (`Cite`, `Ref`, and `LId`) are also removed; only
-`NativeRel`, `NativeHead`, `HeadRepair`, and `SpaceAfter` are retained there.
+[`scripts/audit_leakage.py`](scripts/audit_leakage.py) measures what remains by
+fitting classifiers that see annotation markup and no Greek at all, and writes
+[`metadata/leakage_report.json`](metadata/leakage_report.json). Those numbers
+are the floor a real model must clear: a system that does not beat them has
+demonstrated source identification rather than authorship attribution. They are
+published on the leaderboard for that reason, and the `source_held_out_*` track
+exists because they cannot be driven to chance.
 
 ## Deduplication
 
@@ -261,6 +391,7 @@ python scripts/build_dataset.py --sources /path/to/frozen/checkouts \
   --metre-output ../sphragis-metre/data \
   --metre-metadata ../sphragis-metre/metadata \
   --stoicheia-conllu .stoicheia-cache/hypotactic_conllu_punctuationless_udv2.jsonl
+python scripts/audit_leakage.py --data data --metadata metadata
 python scripts/validate_publication.py --publication sentence --data data
 python scripts/validate_publication.py \
   --publication metre --data ../sphragis-metre/data

SOURCES.md

@@ -19,12 +19,18 @@ The beta integrates:
 
 Non-UD dependency trees are serialized as valid CoNLL-U without claiming that
 their relations have been manually reannotated as Universal Dependencies.
-Heads are preserved, a best-effort UPOS/features conversion is supplied,
-native relations are represented as `dep:<native-relation>`, and the original
-relation and head are retained as `NativeRel` and `NativeHead` in MISC. Empty
-and artificial ellipsis nodes are omitted. If this would leave no surface root,
-or if an upstream beta tree contains a self-loop/cycle, the smallest necessary
-repair is marked `HeadRepair=Yes`.
+Heads are preserved and a best-effort UPOS/features conversion is supplied.
+Empty and artificial ellipsis nodes are omitted. If this would leave no surface
+root, or if an upstream beta tree contains a self-loop/cycle, the smallest
+necessary repair is applied.
+
+Because the seven projects do not overlap in authors, their annotation
+conventions identify authors. Every published tree is therefore reduced to one
+shared inventory of parts of speech, features and dependency relations,
+stripped of punctuation, comments and MISC, and lowercased; the original
+relation, head and any repair are preserved per token in the `native_syntax`
+column. See "Model-facing representation" in the README, and
+`metadata/leakage_report.json` for the measured residual.
 
 Exact sentence duplicates across prose and verse are identified by lowercasing, converting final sigma,
 removing diacritics, and retaining letters only. One syntactic representation

data/sentence_1/test-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ad55c6f23b4ba1dc42abe1bc150a091dc87957a4e399934f894af5e91edef891
-size 1968403
+oid sha256:f6b955124e767a679f22f5831beeea2521d6eb8449ef9aa7fe12067478877d51
+size 1801614

data/sentence_1/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:067cff2d494fd4634e5dc96490df9e4e6e1e96097c579c6ac1588a8432b6ad44
-size 17324579
+oid sha256:68a53a6675832c3b3a4f0d1d353a46a3f25ba847b62bff2d3d79ea355d3d3d5f
+size 15710369

data/sentence_1/validation-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2ac869c4d9a54177e52be472027539134b20adb6e4249392b45e0fad7c94c699
-size 1953585
+oid sha256:48afb349a9743ccce2906f36e720ddfbd07a819292da4f14899355990c9ea91a
+size 1782350

data/sentence_10/test-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5ecdd99f802b600356dfe4a440dc98276bfffa8b4420d5e26b74cfe8d824ad0b
-size 1653944
+oid sha256:1886acd279e524a4a2c030ad7d50d07fb518436ec048189b0dac80b80e17f297
+size 1516058

data/sentence_10/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:af764f6eaffbf8d9bfc63e822273a63023f5a3cd984c8b081fe6ba51ae86286e
-size 13245244
+oid sha256:fdcdc569edd363708d4d3c36df811d8bf2f459d1a0dd6d799739d6cd8fa42a5e
+size 12197728

data/sentence_10/validation-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:65eb9527a57ce29a9551a42c329ce285c0501f01b2c0d27cc8023b419f2bc20e
-size 1634568
+oid sha256:6df7e15fc7d3c83cf7093613bfde26922699af463ac3257954d6c021807d8b62
+size 1497141

data/sentence_100/test-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f1504f10076c7de58e34fa57e67502c18cbeee04403c1d9ff56c0bb86075ccae
-size 1588918
+oid sha256:c9cb775a24a9df9b4a86fd856c4d40cb43675457360cf8564e9460f5947bbbcc
+size 1448714

data/sentence_100/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:91b6f94d0b4cb560542fac18ad1de3986e74ebc88c83c644f33e4b67655bcf1b
-size 12827249
+oid sha256:aadad114cb26e6bf6866d8936007f721e1fcc15a8ce386fcdedbd45ed458e5bd
+size 11739798

data/sentence_100/validation-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c68535eaf5f3037d86c5a9d253e5bd903e78ffdeef5417bb7287f0765827bfe8
-size 1577597
+oid sha256:bb738b386bb359e532197c0d0354e3df98cb538d44fb6a635a77ca844fd774e4
+size 1437967

data/sentence_50/test-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:63a0be018cd297899b0db08dcd1da8a6fc194c7230143a6b0012b3db6b1e04d1
-size 1594282
+oid sha256:5e1fbee9bb71b752f83abcc64c4faf538266fec2900460c484435ae14811b321
+size 1454270

data/sentence_50/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dbc570ab5bd97d2c441373b14bd232b1b592b0291c13360431921896b3e05bb3
-size 12868346
+oid sha256:dbf0be2e803934c1c14bdbfadd57dd60767cbd7852a6c49c559ffda79609f7d6
+size 11784864

data/sentence_50/validation-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:69b2a39bd530f1f149556f198e62f0792a8af38c5caf70a77391eb8bca7d5874
-size 1582843
+oid sha256:4092d9ba16f513811445f7ca3182bbe5e5c33cdac1291216108484cb020d011a
+size 1443442

data/source_held_out_1/test-00000-of-00001.parquet

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

data/source_held_out_1/train-00000-of-00001.parquet

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

data/source_held_out_1/validation-00000-of-00001.parquet

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

data/source_held_out_10/test-00000-of-00001.parquet

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

data/source_held_out_10/train-00000-of-00001.parquet

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

data/source_held_out_10/validation-00000-of-00001.parquet

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

data/source_held_out_100/test-00000-of-00001.parquet

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

data/source_held_out_100/train-00000-of-00001.parquet

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

data/source_held_out_100/validation-00000-of-00001.parquet

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

data/source_held_out_50/test-00000-of-00001.parquet

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

data/source_held_out_50/train-00000-of-00001.parquet

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

data/source_held_out_50/validation-00000-of-00001.parquet

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

inspection/sphragis.sqlite

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ef1b7d6fbe11364a00c4028b8c77589b0840753e790b295fc8f394e4780e9f47
-size 795017216
+oid sha256:72eefbb52ba62741072d6478aaf3b67b51ac98a88d3f357992272f5f43d2de72
+size 1237647360

metadata/build_report.json

@@ -373,6 +373,26 @@
       "test": 96,
       "train": 866,
       "validation": 96
+    },
+    "source_held_out_1": {
+      "test": 4200,
+      "train": 25100,
+      "validation": 4200
+    },
+    "source_held_out_10": {
+      "test": 420,
+      "train": 2510,
+      "validation": 420
+    },
+    "source_held_out_100": {
+      "test": 42,
+      "train": 251,
+      "validation": 42
+    },
+    "source_held_out_50": {
+      "test": 84,
+      "train": 502,
+      "validation": 84
     }
   },
   "deduplication": {
@@ -730,7 +750,466 @@
       "papyri.xml"
     ]
   },
+  "model_facing_normalization": {
+    "case": "word forms, lemmas and text are lowercased with grc_utils.lower_grc",
+    "conllu_comments": "removed; the text column carries the text",
+    "deprel_inventory": [
+      "advmod",
+      "appos",
+      "case",
+      "ccomp",
+      "conj",
+      "dep",
+      "discourse",
+      "nmod",
+      "nsubj",
+      "obj",
+      "obl",
+      "root",
+      "vocative"
+    ],
+    "feats_inventory": [
+      "Case",
+      "Degree",
+      "Gender",
+      "Mood",
+      "Number",
+      "Person",
+      "Tense",
+      "Voice"
+    ],
+    "misc": "cleared; NativeRel, NativeHead and HeadRepair move to native_syntax",
+    "punctuation": "editorial punctuation tokens are removed from CoNLL-U and from text, because UD PROIEL does not tokenize punctuation at all",
+    "rationale": "Sphragis merges seven annotation projects whose author inventories do not overlap, so any convention that distinguishes those projects also identifies the author. Every published column is reduced to one shared representation; the project-specific annotation is retained for audit in the native_syntax column.",
+    "statistics": {
+      "rows": 67568,
+      "units": 67568,
+      "units_with_native_syntax": 47556
+    },
+    "upos_inventory": [
+      "ADJ",
+      "ADP",
+      "ADV",
+      "INTJ",
+      "NOUN",
+      "NUM",
+      "PRON",
+      "VERB",
+      "X"
+    ],
+    "xpos_part_of_speech_inventory": [
+      "a",
+      "d",
+      "i",
+      "m",
+      "n",
+      "p",
+      "r",
+      "v",
+      "x"
+    ]
+  },
   "publication": "sentence",
+  "source_held_out_track": {
+    "author_decisions": {
+      "Athenaeus": {
+        "held_out_source": "gorman",
+        "rows": {
+          "test": 424,
+          "train": 1628,
+          "validation": 424
+        },
+        "source_rows": {
+          "agdt": 11,
+          "gorman": 848,
+          "ud_perseus": 1617
+        },
+        "training_sources": [
+          "ud_perseus",
+          "agdt"
+        ]
+      },
+      "Diodorus Siculus": {
+        "held_out_source": "gorman",
+        "rows": {
+          "test": 227,
+          "train": 828,
+          "validation": 227
+        },
+        "source_rows": {
+          "agdt": 104,
+          "gorman": 455,
+          "ud_perseus": 724
+        },
+        "training_sources": [
+          "ud_perseus",
+          "agdt"
+        ]
+      },
+      "Herodotus": {
+        "held_out_source": "ud_perseus",
+        "rows": {
+          "test": 546,
+          "train": 6285,
+          "validation": 546
+        },
+        "source_rows": {
+          "agdt": 5,
+          "gorman": 179,
+          "ud_perseus": 1092,
+          "ud_proiel": 6101
+        },
+        "training_sources": [
+          "ud_proiel",
+          "gorman",
+          "agdt"
+        ]
+      },
+      "Hesiod": {
+        "held_out_source": "agdt",
+        "rows": {
+          "test": 183,
+          "train": 547,
+          "validation": 183
+        },
+        "source_rows": {
+          "agdt": 366,
+          "ud_perseus": 547
+        },
+        "training_sources": [
+          "ud_perseus"
+        ]
+      },
+      "Homeric-Iliad": {
+        "held_out_source": "agdt",
+        "rows": {
+          "test": 1158,
+          "train": 5527,
+          "validation": 1158
+        },
+        "source_rows": {
+          "agdt": 2316,
+          "ud_perseus": 5527
+        },
+        "training_sources": [
+          "ud_perseus"
+        ]
+      },
+      "Lucian": {
+        "held_out_source": "harrington",
+        "rows": {
+          "test": 161,
+          "train": 397,
+          "validation": 161
+        },
+        "source_rows": {
+          "harrington": 322,
+          "pedalion": 397
+        },
+        "training_sources": [
+          "pedalion"
+        ]
+      },
+      "Plato": {
+        "held_out_source": "agdt",
+        "rows": {
+          "test": 183,
+          "train": 779,
+          "validation": 183
+        },
+        "source_rows": {
+          "agdt": 366,
+          "gorman": 724,
+          "pedalion": 55
+        },
+        "training_sources": [
+          "gorman",
+          "pedalion"
+        ]
+      },
+      "Plutarch": {
+        "held_out_source": "ud_perseus",
+        "rows": {
+          "test": 248,
+          "train": 1157,
+          "validation": 248
+        },
+        "source_rows": {
+          "agdt": 100,
+          "gorman": 1057,
+          "ud_perseus": 496
+        },
+        "training_sources": [
+          "gorman",
+          "agdt"
+        ]
+      },
+      "Sophocles": {
+        "held_out_source": "agdt",
+        "rows": {
+          "test": 781,
+          "train": 2314,
+          "validation": 781
+        },
+        "source_rows": {
+          "agdt": 1563,
+          "ud_perseus": 2314
+        },
+        "training_sources": [
+          "ud_perseus"
+        ]
+      },
+      "Thucydides": {
+        "held_out_source": "ud_perseus",
+        "rows": {
+          "test": 265,
+          "train": 674,
+          "validation": 265
+        },
+        "source_rows": {
+          "agdt": 2,
+          "gorman": 672,
+          "ud_perseus": 531
+        },
+        "training_sources": [
+          "gorman",
+          "agdt"
+        ]
+      },
+      "Xenophon": {
+        "held_out_source": "pedalion",
+        "rows": {
+          "test": 637,
+          "train": 5578,
+          "validation": 637
+        },
+        "source_rows": {
+          "gorman": 5578,
+          "pedalion": 1275
+        },
+        "training_sources": [
+          "gorman"
+        ]
+      }
+    },
+    "excluded_authors": {
+      "Aeneas Tacticus": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 300
+        }
+      },
+      "Aeschines": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 666
+        }
+      },
+      "Aeschylus": {
+        "held_out_source": "ud_perseus",
+        "reason": "held-out source too small for a 100-row validation and test split",
+        "sources": {
+          "agdt": 3115,
+          "ud_perseus": 163
+        }
+      },
+      "Andocides": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 269
+        }
+      },
+      "Antiphon": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 513
+        }
+      },
+      "Appian": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 966
+        }
+      },
+      "Aristophanes": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 1853
+        }
+      },
+      "Aristotle": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 871
+        }
+      },
+      "Chariton": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 402
+        }
+      },
+      "Demosthenes": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 3035
+        }
+      },
+      "Dionysius of Halicarnassus": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 1063
+        }
+      },
+      "Epicurus": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 67
+        }
+      },
+      "Euripides": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 793
+        }
+      },
+      "Ezechiel": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 146
+        }
+      },
+      "Heron": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 484
+        }
+      },
+      "Homeric-Odyssey": {
+        "reason": "only one source project",
+        "sources": {
+          "agdt": 6100
+        }
+      },
+      "Isaeus": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 194
+        }
+      },
+      "Isocrates": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 153
+        }
+      },
+      "Josephus": {
+        "reason": "only one source project",
+        "sources": {
+          "gorman": 1039
+        }
+      },
+      "Julian": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 50
+        }
+      },
+      "Longus": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 34
+        }
+      },
+      "Lysias": {
+        "held_out_source": "pedalion",
+        "reason": "held-out source too small for a 100-row validation and test split",
+        "sources": {
+          "agdt": 54,
+          "gorman": 833,
+          "pedalion": 80
+        }
+      },
+      "Menander": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 895
+        }
+      },
+      "Paeanius": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 360
+        }
+      },
+      "Paul": {
+        "reason": "only one source project",
+        "sources": {
+          "ud_proiel": 900
+        }
+      },
+      "Phlegon": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 237
+        }
+      },
+      "Polybius": {
+        "held_out_source": "agdt",
+        "reason": "held-out source too small for a 100-row validation and test split",
+        "sources": {
+          "agdt": 1,
+          "gorman": 3804
+        }
+      },
+      "Procopius": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 1188
+        }
+      },
+      "Sappho": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 402
+        }
+      },
+      "Semonides": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 58
+        }
+      },
+      "Sextus Empiricus": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 677
+        }
+      },
+      "Theophrastus": {
+        "reason": "only one source project",
+        "sources": {
+          "pedalion": 459
+        }
+      }
+    },
+    "minimum_rows_per_split": 100,
+    "policy": "hold out each author's second-largest source project entirely; its sentences form that author's validation and test data and every other project supplies training",
+    "retained_authors": [
+      "Athenaeus",
+      "Diodorus Siculus",
+      "Herodotus",
+      "Hesiod",
+      "Homeric-Iliad",
+      "Lucian",
+      "Plato",
+      "Plutarch",
+      "Sophocles",
+      "Thucydides",
+      "Xenophon"
+    ],
+    "seed": 776
+  },
   "splitting": {
     "chunking": {
       "ordering": "natural passage or line order within canonical work ID",
@@ -807,6 +1286,358 @@
         "train": 866,
         "validation": 96
       }
+    },
+    "source_held_out_1": {
+      "authors": 11,
+      "genres": [
+        "prose",
+        "verse"
+      ],
+      "held_out_sources": {
+        "Athenaeus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Diodorus Siculus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Herodotus": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman",
+            "ud_proiel"
+          ]
+        },
+        "Hesiod": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Homeric-Iliad": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Lucian": {
+          "held_out_source": "harrington",
+          "training_sources": [
+            "pedalion"
+          ]
+        },
+        "Plato": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "gorman",
+            "pedalion"
+          ]
+        },
+        "Plutarch": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Sophocles": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Thucydides": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Xenophon": {
+          "held_out_source": "pedalion",
+          "training_sources": [
+            "gorman"
+          ]
+        }
+      },
+      "rows": 33500,
+      "splits": {
+        "test": 4200,
+        "train": 25100,
+        "validation": 4200
+      }
+    },
+    "source_held_out_10": {
+      "authors": 11,
+      "genres": [
+        "prose",
+        "verse"
+      ],
+      "held_out_sources": {
+        "Athenaeus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Diodorus Siculus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Herodotus": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman",
+            "ud_proiel"
+          ]
+        },
+        "Hesiod": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Homeric-Iliad": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Lucian": {
+          "held_out_source": "harrington",
+          "training_sources": [
+            "pedalion"
+          ]
+        },
+        "Plato": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "gorman",
+            "pedalion"
+          ]
+        },
+        "Plutarch": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Sophocles": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Thucydides": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Xenophon": {
+          "held_out_source": "pedalion",
+          "training_sources": [
+            "gorman"
+          ]
+        }
+      },
+      "rows": 3350,
+      "splits": {
+        "test": 420,
+        "train": 2510,
+        "validation": 420
+      }
+    },
+    "source_held_out_100": {
+      "authors": 11,
+      "genres": [
+        "prose",
+        "verse"
+      ],
+      "held_out_sources": {
+        "Athenaeus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Diodorus Siculus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Herodotus": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman",
+            "ud_proiel"
+          ]
+        },
+        "Hesiod": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Homeric-Iliad": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Lucian": {
+          "held_out_source": "harrington",
+          "training_sources": [
+            "pedalion"
+          ]
+        },
+        "Plato": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "gorman",
+            "pedalion"
+          ]
+        },
+        "Plutarch": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Sophocles": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Thucydides": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Xenophon": {
+          "held_out_source": "pedalion",
+          "training_sources": [
+            "gorman"
+          ]
+        }
+      },
+      "rows": 335,
+      "splits": {
+        "test": 42,
+        "train": 251,
+        "validation": 42
+      }
+    },
+    "source_held_out_50": {
+      "authors": 11,
+      "genres": [
+        "prose",
+        "verse"
+      ],
+      "held_out_sources": {
+        "Athenaeus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Diodorus Siculus": {
+          "held_out_source": "gorman",
+          "training_sources": [
+            "agdt",
+            "ud_perseus"
+          ]
+        },
+        "Herodotus": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman",
+            "ud_proiel"
+          ]
+        },
+        "Hesiod": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Homeric-Iliad": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Lucian": {
+          "held_out_source": "harrington",
+          "training_sources": [
+            "pedalion"
+          ]
+        },
+        "Plato": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "gorman",
+            "pedalion"
+          ]
+        },
+        "Plutarch": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Sophocles": {
+          "held_out_source": "agdt",
+          "training_sources": [
+            "ud_perseus"
+          ]
+        },
+        "Thucydides": {
+          "held_out_source": "ud_perseus",
+          "training_sources": [
+            "agdt",
+            "gorman"
+          ]
+        },
+        "Xenophon": {
+          "held_out_source": "pedalion",
+          "training_sources": [
+            "gorman"
+          ]
+        }
+      },
+      "rows": 670,
+      "splits": {
+        "test": 84,
+        "train": 502,
+        "validation": 84
+      }
     }
   }
 }

metadata/leakage_report.json

@@ -0,0 +1,201 @@
+{
+  "configurations": {
+    "sentence_1": {
+      "authors": 17,
+      "inventory_to_author": {
+        "accuracy": 36.5208,
+        "features": 55,
+        "macro_f1": 17.9549
+      },
+      "majority_baseline": {
+        "accuracy": 14.5833,
+        "features": 0,
+        "macro_f1": 1.4973
+      },
+      "markup_to_author": {
+        "accuracy": 52.7083,
+        "features": 116,
+        "macro_f1": 34.0167
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 82.3125,
+        "features": 116,
+        "macro_f1": 76.3751
+      },
+      "test_rows": 4800
+    },
+    "sentence_10": {
+      "authors": 17,
+      "inventory_to_author": {
+        "accuracy": 39.7917,
+        "features": 55,
+        "macro_f1": 16.6515
+      },
+      "majority_baseline": {
+        "accuracy": 14.5833,
+        "features": 0,
+        "macro_f1": 1.4973
+      },
+      "markup_to_author": {
+        "accuracy": 79.5833,
+        "features": 116,
+        "macro_f1": 65.9773
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 88.125,
+        "features": 116,
+        "macro_f1": 70.5903
+      },
+      "test_rows": 480
+    },
+    "sentence_100": {
+      "authors": 17,
+      "inventory_to_author": {
+        "accuracy": 50.0,
+        "features": 55,
+        "macro_f1": 27.274
+      },
+      "majority_baseline": {
+        "accuracy": 14.5833,
+        "features": 0,
+        "macro_f1": 1.4973
+      },
+      "markup_to_author": {
+        "accuracy": 72.9167,
+        "features": 116,
+        "macro_f1": 41.6694
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 64.5833,
+        "features": 116,
+        "macro_f1": 53.377
+      },
+      "test_rows": 48
+    },
+    "sentence_50": {
+      "authors": 17,
+      "inventory_to_author": {
+        "accuracy": 47.9167,
+        "features": 55,
+        "macro_f1": 28.9223
+      },
+      "majority_baseline": {
+        "accuracy": 14.5833,
+        "features": 0,
+        "macro_f1": 1.4973
+      },
+      "markup_to_author": {
+        "accuracy": 78.125,
+        "features": 116,
+        "macro_f1": 48.9063
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 75.0,
+        "features": 116,
+        "macro_f1": 62.6627
+      },
+      "test_rows": 96
+    },
+    "source_held_out_1": {
+      "authors": 11,
+      "inventory_to_author": {
+        "accuracy": 16.881,
+        "features": 55,
+        "macro_f1": 7.6827
+      },
+      "majority_baseline": {
+        "accuracy": 11.9048,
+        "features": 0,
+        "macro_f1": 1.9342
+      },
+      "markup_to_author": {
+        "accuracy": 22.0238,
+        "features": 116,
+        "macro_f1": 11.1817
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 35.3095,
+        "features": 116,
+        "macro_f1": 20.9741
+      },
+      "test_rows": 4200
+    },
+    "source_held_out_10": {
+      "authors": 11,
+      "inventory_to_author": {
+        "accuracy": 12.8571,
+        "features": 55,
+        "macro_f1": 4.5931
+      },
+      "majority_baseline": {
+        "accuracy": 11.9048,
+        "features": 0,
+        "macro_f1": 1.9342
+      },
+      "markup_to_author": {
+        "accuracy": 42.619,
+        "features": 116,
+        "macro_f1": 28.8832
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 33.8095,
+        "features": 116,
+        "macro_f1": 17.7488
+      },
+      "test_rows": 420
+    },
+    "source_held_out_100": {
+      "authors": 11,
+      "inventory_to_author": {
+        "accuracy": 23.8095,
+        "features": 55,
+        "macro_f1": 8.2867
+      },
+      "majority_baseline": {
+        "accuracy": 11.9048,
+        "features": 0,
+        "macro_f1": 1.9342
+      },
+      "markup_to_author": {
+        "accuracy": 28.5714,
+        "features": 116,
+        "macro_f1": 12.6748
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 21.4286,
+        "features": 116,
+        "macro_f1": 11.413
+      },
+      "test_rows": 42
+    },
+    "source_held_out_50": {
+      "authors": 11,
+      "inventory_to_author": {
+        "accuracy": 7.1429,
+        "features": 55,
+        "macro_f1": 2.7308
+      },
+      "majority_baseline": {
+        "accuracy": 11.9048,
+        "features": 0,
+        "macro_f1": 1.9342
+      },
+      "markup_to_author": {
+        "accuracy": 30.9524,
+        "features": 116,
+        "macro_f1": 19.9491
+      },
+      "markup_to_treebank_source": {
+        "accuracy": 25.0,
+        "features": 116,
+        "macro_f1": 12.4508
+      },
+      "test_rows": 84
+    }
+  },
+  "probes": {
+    "inventory": "binary presence of each tag, feature, relation and MISC key",
+    "markup": "non-lexical rates over UPOS, DEPREL, FEATS, MISC and XPOS"
+  },
+  "purpose": "Scheme-only baselines. These classifiers see annotation markup and no Greek at all; a model that does not clearly beat them has demonstrated source identification, not authorship attribution."
+}

requirements-build.txt

@@ -1,3 +1,5 @@
 edlib>=1.3.9,<2
 grc-utils==0.2.2
 pyarrow>=21,<22
+# scripts/audit_leakage.py fits the scheme-only baselines.
+scikit-learn>=1.4

scripts/audit_leakage.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""Measure how much of Sphragis is solvable without reading any Greek.
+
+Sphragis merges seven annotation projects whose author inventories do not
+overlap, so the annotation scheme is itself a partial answer key. This script
+fits deliberately crippled classifiers that see only annotation *markup* — no
+word forms, no lemmas — and reports what they score. Any model that does not
+clearly beat these numbers has demonstrated source identification rather than
+authorship attribution, and the leaderboard publishes them for that reason.
+
+Two probes:
+
+``inventory``
+    43 binary flags recording only which tags, features, relations and MISC
+    keys a document happens to use. It cannot represent frequency, word order
+    or any word.
+``markup``
+    Rates over UPOS, DEPREL, FEATS keys, MISC keys and XPOS positions, plus
+    token count. Still entirely non-lexical.
+
+It also reports how recoverable ``treebank_source`` itself is, which is the
+quantity the normalization is trying to reduce.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import json
+from pathlib import Path
+
+import pyarrow.parquet as pq
+from sklearn.feature_extraction import DictVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, f1_score
+
+try:
+    from scripts.conllu_units import load_conllu_units
+except ModuleNotFoundError:  # Direct execution from the scripts directory.
+    from conllu_units import load_conllu_units
+
+
+SPLITS = ("train", "validation", "test")
+
+FLAG_UPOS = ("NOUN", "VERB", "ADJ", "PRON", "ADV", "ADP", "NUM", "INTJ", "X",
+             "PUNCT", "PROPN", "AUX", "CCONJ", "SCONJ", "PART", "DET")
+FLAG_FEATS = ("Case", "Gender", "Number", "Person", "Tense", "Mood", "Voice",
+              "Degree", "VerbForm", "PronType", "Definite", "Aspect")
+FLAG_MISC = ("NativeRel", "NativeHead", "HeadRepair", "SpaceAfter")
+FLAG_DEPREL = ("root", "nsubj", "obj", "ccomp", "obl", "nmod", "advmod", "case",
+               "conj", "appos", "vocative", "discourse", "dep", "cc", "cop",
+               "iobj", "punct", "det", "amod", "dislocated", "nsubj:pass")
+
+
+def tokens(conllu: str) -> list[list[str]]:
+    return [
+        line.split("\t") for line in conllu.splitlines()
+        if line and not line.startswith("#") and len(line.split("\t")) == 10
+    ]
+
+
+def inventory_features(units: list[str]) -> dict[str, float]:
+    upos, feats, misc, deprel = set(), set(), set(), set()
+    empty_misc = True
+    has_punct = False
+    for unit in units:
+        for token in tokens(unit):
+            upos.add(token[3])
+            deprel.add(token[7])
+            has_punct = has_punct or token[3] == "PUNCT"
+            if token[5] != "_":
+                feats.update(item.split("=", 1)[0] for item in token[5].split("|"))
+            if token[9] != "_":
+                empty_misc = False
+                misc.update(item.split("=", 1)[0] for item in token[9].split("|"))
+    features = {f"U:{key}": float(key in upos) for key in FLAG_UPOS}
+    features.update({f"F:{key}": float(key in feats) for key in FLAG_FEATS})
+    features.update({f"M:{key}": float(key in misc) for key in FLAG_MISC})
+    features.update({f"R:{key}": float(key in deprel) for key in FLAG_DEPREL})
+    features["empty-misc"] = float(empty_misc)
+    features["no-punct"] = float(not has_punct)
+    return features
+
+
+def markup_features(units: list[str]) -> dict[str, float]:
+    counts: Counter[str] = Counter()
+    total = 0
+    for unit in units:
+        for token in tokens(unit):
+            total += 1
+            counts[f"u:{token[3]}"] += 1
+            counts[f"r:{token[7]}"] += 1
+            if token[5] == "_":
+                counts["f:none"] += 1
+            else:
+                for item in token[5].split("|"):
+                    counts[f"f:{item}"] += 1
+            if token[9] == "_":
+                counts["m:none"] += 1
+            else:
+                for item in token[9].split("|"):
+                    counts[f"m:{item.split('=', 1)[0]}"] += 1
+            if token[4] != "_":
+                for position, value in enumerate(token[4]):
+                    counts[f"x{position}:{value}"] += 1
+    total = max(total, 1)
+    features = {key: value / total for key, value in counts.items()}
+    features["tokens"] = total / 50.0
+    return features
+
+
+def read_config(data: Path, config: str) -> dict[str, list[dict]]:
+    rows = {}
+    for split in SPLITS:
+        path = data / config / f"{split}-00000-of-00001.parquet"
+        rows[split] = pq.read_table(
+            path, columns=["author", "treebank_source", "conllu"],
+        ).to_pylist()
+    return rows
+
+
+def score(rows: dict[str, list[dict]], featurizer, label: str) -> dict:
+    vectorizer = DictVectorizer(sparse=True)
+    train = [featurizer(load_conllu_units(row["conllu"])) for row in rows["train"]]
+    test = [featurizer(load_conllu_units(row["conllu"])) for row in rows["test"]]
+    x_train = vectorizer.fit_transform(train)
+    x_test = vectorizer.transform(test)
+    y_train = [row[label] for row in rows["train"]]
+    y_test = [row[label] for row in rows["test"]]
+    model = LogisticRegression(max_iter=3000).fit(x_train, y_train)
+    predicted = model.predict(x_test)
+    return {
+        "features": int(x_train.shape[1]),
+        "accuracy": round(100 * accuracy_score(y_test, predicted), 4),
+        "macro_f1": round(100 * f1_score(y_test, predicted, average="macro"), 4),
+    }
+
+
+def majority_baseline(rows: dict[str, list[dict]], label: str) -> dict:
+    commonest = Counter(row[label] for row in rows["train"]).most_common(1)[0][0]
+    y_test = [row[label] for row in rows["test"]]
+    predicted = [commonest] * len(y_test)
+    return {
+        "features": 0,
+        "accuracy": round(100 * accuracy_score(y_test, predicted), 4),
+        "macro_f1": round(100 * f1_score(y_test, predicted, average="macro"), 4),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data", type=Path, default=Path("data"))
+    parser.add_argument("--metadata", type=Path, default=Path("metadata"))
+    parser.add_argument(
+        "--configs", nargs="*",
+        default=[
+            *(f"sentence_{suffix}" for suffix in (1, 10, 50, 100)),
+            *(f"source_held_out_{suffix}" for suffix in (1, 10, 50, 100)),
+        ],
+    )
+    args = parser.parse_args()
+
+    report = {
+        "purpose": (
+            "Scheme-only baselines. These classifiers see annotation markup and "
+            "no Greek at all; a model that does not clearly beat them has "
+            "demonstrated source identification, not authorship attribution."
+        ),
+        "probes": {
+            "inventory": "binary presence of each tag, feature, relation and MISC key",
+            "markup": "non-lexical rates over UPOS, DEPREL, FEATS, MISC and XPOS",
+        },
+        "configurations": {},
+    }
+    for config in args.configs:
+        rows = read_config(args.data, config)
+        entry = {
+            "test_rows": len(rows["test"]),
+            "authors": len({row["author"] for row in rows["train"]}),
+            "majority_baseline": majority_baseline(rows, "author"),
+            "inventory_to_author": score(rows, inventory_features, "author"),
+            "markup_to_author": score(rows, markup_features, "author"),
+            "markup_to_treebank_source": score(
+                rows, markup_features, "treebank_source",
+            ),
+        }
+        report["configurations"][config] = entry
+        print(config, json.dumps(entry, indent=2), flush=True)
+
+    args.metadata.mkdir(parents=True, exist_ok=True)
+    output = args.metadata / "leakage_report.json"
+    output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+    print(f"wrote {output}")
+
+
+if __name__ == "__main__":
+    main()

scripts/build_dataset.py

@@ -30,7 +30,11 @@ import pyarrow.parquet as pq
 from grc_utils import vowel
 
 try:
-    from scripts.conllu_units import load_conllu_units
+    from scripts.conllu_units import (
+        encode_conllu_units,
+        load_conllu_units,
+        source_conllu_units,
+    )
     from scripts.dataset_variants import (
         fields_first,
         make_dataset_variants,
@@ -38,20 +42,63 @@ try:
     )
     from scripts.metre_units import load_metre_units, load_syllable_units
     from scripts.metrical_lines import cropped_public_metrical_line, load_public_metrical_lines
-    from scripts.text_units import load_text_units
-    from scripts.syntax_normalization import is_universal_deprel, syntax_text_normalize
+    from scripts.text_units import (
+        encode_text_units,
+        load_text_units,
+        source_text_units,
+    )
+    from scripts.syntax_normalization import (
+        CORE_DEPRELS,
+        CORE_FEATS,
+        CORE_XPOS_POS,
+        is_universal_deprel,
+        syntax_text_normalize,
+    )
+    from scripts.model_facing import (
+        CORE_UPOS,
+        check_model_facing_conllu,
+        encode_native_syntax,
+        finalize_conllu_unit,
+        lower_greek,
+        punctuationless_text,
+    )
     from scripts.vendor.conll18_ud_eval import UDError, load_conllu
 except ModuleNotFoundError:  # Direct execution from the scripts directory.
-    from conllu_units import load_conllu_units
+    from conllu_units import (
+        encode_conllu_units,
+        load_conllu_units,
+        source_conllu_units,
+    )
     from dataset_variants import fields_first, make_dataset_variants, variant_schema
     from metre_units import load_metre_units, load_syllable_units
     from metrical_lines import cropped_public_metrical_line, load_public_metrical_lines
-    from text_units import load_text_units
-    from syntax_normalization import is_universal_deprel, syntax_text_normalize
+    from text_units import (
+        encode_text_units,
+        load_text_units,
+        source_text_units,
+    )
+    from syntax_normalization import (
+        CORE_DEPRELS,
+        CORE_FEATS,
+        CORE_XPOS_POS,
+        is_universal_deprel,
+        syntax_text_normalize,
+    )
+    from model_facing import (
+        CORE_UPOS,
+        check_model_facing_conllu,
+        encode_native_syntax,
+        finalize_conllu_unit,
+        lower_greek,
+        punctuationless_text,
+    )
     from vendor.conll18_ud_eval import UDError, load_conllu
 
 
 RANDOM_SEED = 776
+# MISC keys retained while trees are still assembled internally. None of them
+# reach the published columns: finalize_publication_rows lifts them into the
+# separate native_syntax audit column and clears MISC.
 SAFE_CONLLU_MISC_KEYS = {"NativeRel", "NativeHead", "HeadRepair", "SpaceAfter"}
 
 
@@ -1955,6 +2002,143 @@ def assign_splits(rows: list[dict]) -> None:
             row["split"] = split
 
 
+def finalize_publication_rows(rows: list[dict]) -> dict:
+    """Reduce every row to the scheme-neutral model-facing representation.
+
+    This is the single choke point at which authorship-identifying annotation
+    conventions are removed. It runs after deduplication and splitting so that
+    the published author inventory, split assignment and chunk boundaries are
+    unchanged by it.
+    """
+    stats = Counter()
+    for row in rows:
+        documents = []
+        native = []
+        for unit in source_conllu_units(row["conllu"]):
+            document, unit_native = finalize_conllu_unit(unit)
+            documents.append(document)
+            native.append(unit_native)
+            stats["units"] += 1
+            stats["units_with_native_syntax"] += bool(unit_native)
+        texts = []
+        for unit in source_text_units(row["text"]):
+            cleaned = punctuationless_text(lower_greek(unit))
+            if not cleaned:
+                raise ValueError(f"row {row['id']} has no text after normalization")
+            texts.append(cleaned)
+        row["conllu"] = encode_conllu_units(documents)
+        row["text"] = encode_text_units(texts)
+        row["native_syntax"] = encode_native_syntax(native)
+        if "syllables" in row:
+            row["syllables"] = lower_greek_syllables(row["syllables"])
+        stats["rows"] += 1
+    return dict(stats)
+
+
+def lower_greek_syllables(encoded: str) -> str:
+    """Lowercase the Greek transcription inside a metre syllable annotation.
+
+    Accepts both the internal shape, a bare list of syllables, and the
+    published shape, where syllables are grouped into line objects.
+    """
+    payload = json.loads(encoded)
+    entries = payload if isinstance(payload, list) else [payload]
+    for entry in entries:
+        syllables = entry["syllables"] if "syllables" in entry else [entry]
+        for syllable in syllables:
+            syllable["text"] = lower_greek(syllable["text"])
+    return json.dumps(payload, ensure_ascii=False)
+
+
+SOURCE_HELD_OUT_TARGET = 100
+
+
+def source_held_out_rows(rows: list[dict]) -> tuple[list[dict], dict]:
+    """Build the evaluation track in which no author's test annotator is seen in training.
+
+    The confound this track exists to defeat is that Sphragis merges seven
+    annotation projects whose author inventories do not overlap, so the
+    annotation scheme itself predicts the author. Here each retained author's
+    second-largest source project is held out entirely: its sentences become
+    that author's validation and test data, and every other project supplies
+    training. A model that has learned to recognize annotators rather than
+    writers is therefore actively misled, because at evaluation time each
+    author arrives in the scheme it was never trained in.
+    """
+    by_author = defaultdict(lambda: defaultdict(list))
+    for row in rows:
+        by_author[row["author"]][row["treebank_source"]].append(row)
+
+    selected: list[dict] = []
+    decisions = {}
+    rejected = {}
+    for author in sorted(by_author):
+        by_source = by_author[author]
+        ranked = sorted(
+            by_source, key=lambda source: (-len(by_source[source]), source),
+        )
+        if len(ranked) < 2:
+            rejected[author] = {
+                "reason": "only one source project",
+                "sources": {source: len(by_source[source]) for source in ranked},
+            }
+            continue
+        held_out = ranked[1]
+        held_out_rows = by_source[held_out]
+        train_rows = [
+            row for source in ranked if source != held_out
+            for row in by_source[source]
+        ]
+        evaluation = len(held_out_rows) // 2
+        if (
+            evaluation < SOURCE_HELD_OUT_TARGET
+            or len(train_rows) < SOURCE_HELD_OUT_TARGET
+        ):
+            rejected[author] = {
+                "reason": "held-out source too small for a 100-row validation and test split",
+                "held_out_source": held_out,
+                "sources": {source: len(by_source[source]) for source in ranked},
+            }
+            continue
+
+        rng = random.Random(f"{RANDOM_SEED}:source-held-out:{author}")
+        shuffled = sorted(held_out_rows, key=lambda row: row["id"])
+        rng.shuffle(shuffled)
+        assignment = {
+            **{row["id"]: "validation" for row in shuffled[:evaluation]},
+            **{row["id"]: "test" for row in shuffled[evaluation:evaluation * 2]},
+        }
+        for row in train_rows:
+            selected.append({**row, "split": "train", "held_out_source": held_out})
+        for row in shuffled:
+            split = assignment.get(row["id"])
+            if split is not None:
+                selected.append({**row, "split": split, "held_out_source": held_out})
+        decisions[author] = {
+            "held_out_source": held_out,
+            "training_sources": [source for source in ranked if source != held_out],
+            "source_rows": {source: len(by_source[source]) for source in ranked},
+            "rows": {
+                "train": len(train_rows),
+                "validation": evaluation,
+                "test": evaluation,
+            },
+        }
+    selected.sort(key=lambda row: row["id"])
+    return selected, {
+        "policy": (
+            "hold out each author's second-largest source project entirely; its "
+            "sentences form that author's validation and test data and every "
+            "other project supplies training"
+        ),
+        "seed": RANDOM_SEED,
+        "minimum_rows_per_split": SOURCE_HELD_OUT_TARGET,
+        "retained_authors": sorted(decisions),
+        "author_decisions": decisions,
+        "excluded_authors": rejected,
+    }
+
+
 def write_parquet(
     rows: list[dict], output_root: Path, config: str, schema: pa.Schema | None = None,
 ) -> dict:
@@ -1970,15 +2154,63 @@ def write_parquet(
     return stats
 
 
+def row_treebank_sources(row: dict) -> set[str]:
+    """Every source project actually represented in a row, chunk or atomic."""
+    provenance = row.get("constituent_provenance")
+    if provenance:
+        return {
+            record["treebank_source"] for record in json.loads(provenance)
+            if record.get("treebank_source")
+        }
+    return {row["treebank_source"]}
+
+
+def validate_source_held_out(config: str, rows: list[dict]) -> dict:
+    """Assert that no author's evaluation annotator appears in its training data.
+
+    This is the property the whole track exists for. If it ever fails, the
+    track has silently become another in-domain split and its scores mean
+    nothing more than the main track's.
+    """
+    by_author = defaultdict(lambda: defaultdict(set))
+    for row in rows:
+        by_author[row["author"]][row["split"]] |= row_treebank_sources(row)
+    summary = {}
+    for author in sorted(by_author):
+        splits = by_author[author]
+        held_out = {row["held_out_source"] for row in rows if row["author"] == author}
+        assert len(held_out) == 1, (
+            f"{config}: author {author} has inconsistent held_out_source {held_out}"
+        )
+        held_out_source = held_out.pop()
+        evaluation = splits["validation"] | splits["test"]
+        assert evaluation == {held_out_source}, (
+            f"{config}: {author} evaluation data is annotated by {sorted(evaluation)}, "
+            f"expected only the held-out {held_out_source!r}"
+        )
+        assert held_out_source not in splits["train"], (
+            f"{config}: {author} trains on its held-out source {held_out_source!r}"
+        )
+        assert splits["train"], f"{config}: {author} has no training data"
+        summary[author] = {
+            "held_out_source": held_out_source,
+            "training_sources": sorted(splits["train"]),
+        }
+    return summary
+
+
 def validate_publication(
     rows_by_config: dict[str, list[dict]], publication: str,
 ) -> dict:
     """Validate final repository-level rows after the publication split."""
-    expected_configs = (
-        tuple(f"sentence_{suffix}" for suffix in ("1", "10", "50", "100"))
-        if publication == "sentence"
-        else tuple(f"verse_{suffix}" for suffix in ("1", "10", "50", "100"))
-    )
+    suffixes = ("1", "10", "50", "100")
+    if publication == "sentence":
+        expected_configs = (
+            *(f"sentence_{suffix}" for suffix in suffixes),
+            *(f"source_held_out_{suffix}" for suffix in suffixes),
+        )
+    else:
+        expected_configs = tuple(f"verse_{suffix}" for suffix in suffixes)
     assert set(rows_by_config) == set(expected_configs)
     report = {}
     for config in expected_configs:
@@ -2024,6 +2256,8 @@ def validate_publication(
         }
         if publication == "sentence":
             report[config]["genres"] = sorted({row["genre"] for row in rows})
+        if config.startswith("source_held_out"):
+            report[config]["held_out_sources"] = validate_source_held_out(config, rows)
 
     atomic = rows_by_config[expected_configs[0]]
     if publication == "metre":
@@ -2036,17 +2270,25 @@ def validate_publication(
                         feature_authors[feature].add(row["author"])
         assert feature_authors["caesura"] == authors
         assert feature_authors["hiatus"] == authors
-    for config in expected_configs[1:]:
-        for split in ("train", "validation", "test"):
-            expected_ids = {row["id"] for row in atomic if row["split"] == split}
-            represented_ids = [
-                row_id
-                for row in rows_by_config[config]
-                if row["split"] == split
-                for row_id in row["constituent_ids"]
-            ]
-            assert len(represented_ids) == len(set(represented_ids))
-            assert set(represented_ids) == expected_ids
+    for track_prefix in sorted({
+        config.rsplit("_", 1)[0] for config in expected_configs
+    }):
+        track_atomic = rows_by_config[f"{track_prefix}_1"]
+        for config in expected_configs:
+            if config == f"{track_prefix}_1" or not config.startswith(f"{track_prefix}_"):
+                continue
+            for split in ("train", "validation", "test"):
+                expected_ids = {
+                    row["id"] for row in track_atomic if row["split"] == split
+                }
+                represented_ids = [
+                    row_id
+                    for row in rows_by_config[config]
+                    if row["split"] == split
+                    for row_id in row["constituent_ids"]
+                ]
+                assert len(represented_ids) == len(set(represented_ids))
+                assert set(represented_ids) == expected_ids
     report["checks"] = {
         "expected_configurations": True,
         "identical_source_rows_across_task_sizes": True,
@@ -2126,31 +2368,13 @@ def validate(rows_by_config: dict[str, list[dict]]) -> dict:
         for row in rows:
             row_text_units = load_text_units(row["text"])
             for conllu_index, conllu in enumerate(load_conllu_units(row["conllu"])):
-                comments = [
-                    line for line in conllu.splitlines()
-                    if line.startswith("#")
-                ]
-                assert all(line.startswith("# text = ") for line in comments), (
-                    f"Identifying CoNLL-U comment in {config}, row {row['id']}: {comments}"
+                check_model_facing_conllu(conllu, f"{config}, row {row['id']}")
+                assert syntax_text_normalize("".join(
+                    line.split("\t")[1] for line in conllu.splitlines() if line
+                )) == syntax_text_normalize(row_text_units[conllu_index]), (
+                    f"CoNLL-U forms do not reconstruct the text column in "
+                    f"{config}, row {row['id']}"
                 )
-                for line in conllu.splitlines():
-                    if not line or line.startswith("#"):
-                        continue
-                    columns = line.split("\t")
-                    assert len(columns) == 10
-                    if base_config == "verse_metre":
-                        assert is_universal_deprel(columns[7]), columns[7]
-                    misc_keys = {
-                        item.split("=", 1)[0]
-                        for item in columns[9].split("|")
-                        if item != "_"
-                    }
-                    assert misc_keys <= SAFE_CONLLU_MISC_KEYS, (
-                        f"Identifying CoNLL-U MISC field in {config}, "
-                        f"row {row['id']}: {misc_keys}"
-                    )
-                    if base_config == "verse_metre":
-                        assert misc_keys <= {"HeadRepair"}
                 digest = hashlib.sha256(conllu.encode("utf-8")).digest()
                 if digest in checked_conllu:
                     continue
@@ -2316,6 +2540,8 @@ def main() -> None:
     sentence_input, sentence_curation = curate_sentences(sentence_input)
     sentences, dedup_stats = deduplicate_sentences(sentence_input)
     assign_splits(sentences)
+    sentence_finalization = finalize_publication_rows(sentences)
+    held_out_sentences, source_held_out_report = source_held_out_rows(sentences)
 
     hyp = load_hypotactic(args.sources / "hypotactic", all_files=True)
     verse_input, verse_curation = curate_sentences(agdt_verse + pedalion_verse)
@@ -2351,11 +2577,12 @@ def main() -> None:
     # only while consuming the established RNG sequence, then publish machine
     # rows alone. This preserves every existing benchmark split and chunk.
     assign_splits([*verse_metre, *split_rng_padding])
+    metre_finalization = finalize_publication_rows(verse_metre)
     stoicheia_stats["split_rng_padding_gold_rows_not_published"] = len(
         split_rng_padding
     )
     sentence_rows, sentence_variant_report = make_dataset_variants(
-        {"sentence": sentences}
+        {"sentence": sentences, "source_held_out": held_out_sentences}
     )
     metre_rows, metre_variant_report = make_dataset_variants(
         {"verse_metre": verse_metre}
@@ -2365,11 +2592,19 @@ def main() -> None:
 
     sentence_stats = {}
     sentence_schema = pa.Table.from_pylist(sentences).schema
+    held_out_schema = (
+        pa.Table.from_pylist(held_out_sentences).schema
+        if held_out_sentences
+        else sentence_schema
+    )
     for config, rows in sentence_rows.items():
+        base_schema = (
+            held_out_schema
+            if config.startswith("source_held_out")
+            else sentence_schema
+        )
         schema = (
-            sentence_schema
-            if config.endswith("_1")
-            else variant_schema(sentence_schema)
+            base_schema if config.endswith("_1") else variant_schema(base_schema)
         )
         sentence_stats[config] = write_parquet(rows, args.output, config, schema)
     metre_stats = {}
@@ -2415,6 +2650,34 @@ def main() -> None:
             "treebank_sentence_input": sentence_curation,
         },
         "deduplication": dedup_stats,
+        "model_facing_normalization": {
+            "rationale": (
+                "Sphragis merges seven annotation projects whose author "
+                "inventories do not overlap, so any convention that "
+                "distinguishes those projects also identifies the author. "
+                "Every published column is reduced to one shared "
+                "representation; the project-specific annotation is retained "
+                "for audit in the native_syntax column."
+            ),
+            "conllu_comments": "removed; the text column carries the text",
+            "misc": "cleared; NativeRel, NativeHead and HeadRepair move to native_syntax",
+            "punctuation": (
+                "editorial punctuation tokens are removed from CoNLL-U and from "
+                "text, because UD PROIEL does not tokenize punctuation at all"
+            ),
+            "case": (
+                "word forms, lemmas and text are lowercased with "
+                "grc_utils.lower_grc"
+            ),
+            "deprel_inventory": sorted(CORE_DEPRELS - {"punct"}),
+            "feats_inventory": sorted(CORE_FEATS),
+            "upos_inventory": sorted(CORE_UPOS),
+            "xpos_part_of_speech_inventory": sorted(
+                set(CORE_XPOS_POS.values()) - {"u"}
+            ),
+            "statistics": sentence_finalization,
+        },
+        "source_held_out_track": source_held_out_report,
         "splitting": {
             "seed": RANDOM_SEED,
             "strategy": "independent row-level 80/10/10 stratification by author and work",
@@ -2462,6 +2725,10 @@ def main() -> None:
             "disputed_verse_passages": passage_curation,
         },
         "splitting": sentence_report["splitting"],
+        "model_facing_normalization": {
+            **sentence_report["model_facing_normalization"],
+            "statistics": metre_finalization,
+        },
         "alignment": alignment_stats,
         "automatic_syntax": stoicheia_stats,
         "metrical_representation": {

scripts/build_sqlite_mirror.py

@@ -15,7 +15,10 @@ import pyarrow as pa
 import pyarrow.parquet as pq
 
 SPLITS = ("train", "validation", "test")
-CONFIGS = tuple(f"sentence_{suffix}" for suffix in ("1", "10", "50", "100"))
+CONFIGS = (
+    tuple(f"sentence_{suffix}" for suffix in ("1", "10", "50", "100"))
+    + tuple(f"source_held_out_{suffix}" for suffix in ("1", "10", "50", "100"))
+)
 INDEX_COLUMN = "_split_row_index"
 
 
@@ -215,13 +218,13 @@ def main() -> None:
     )
     parser.add_argument("--check", action="store_true")
     args = parser.parse_args()
-    base = "sentence" if args.publication == "sentence" else "verse"
-    suffixes = (
-        ("1", "10", "50", "100")
+    suffixes = ("1", "10", "50", "100")
+    CONFIGS = (
+        tuple(f"sentence_{suffix}" for suffix in suffixes)
+        + tuple(f"source_held_out_{suffix}" for suffix in suffixes)
         if args.publication == "sentence"
-        else ("1", "10", "50", "100")
+        else tuple(f"verse_{suffix}" for suffix in suffixes)
     )
-    CONFIGS = tuple(f"{base}_{suffix}" for suffix in suffixes)
     if not args.check:
         build(args.data, args.output)
     validate(args.data, args.output)

scripts/dataset_variants.py

@@ -12,24 +12,28 @@ import pyarrow as pa
 
 try:
     from scripts.conllu_units import encode_conllu_units, source_conllu_units
+    from scripts.model_facing import encode_native_syntax, load_native_syntax
     from scripts.metre_units import syllable_line
     from scripts.metrical_lines import load_public_metrical_lines
     from scripts.text_units import encode_text_units, source_text_units
 except ModuleNotFoundError:  # Direct execution from the scripts directory.
     from conllu_units import encode_conllu_units, source_conllu_units
+    from model_facing import encode_native_syntax, load_native_syntax
     from metre_units import syllable_line
     from metrical_lines import load_public_metrical_lines
     from text_units import encode_text_units, source_text_units
 
 
-BASE_CONFIGS = ("sentence", "verse_metre")
+BASE_CONFIGS = ("sentence", "source_held_out", "verse_metre")
 SPLITS = ("train", "validation", "test")
 CHUNK_TARGETS_BY_BASE = {
     "sentence": (10, 50, 100),
+    "source_held_out": (10, 50, 100),
     "verse_metre": (10, 50, 100),
 }
 PUBLIC_CONFIG_PREFIX = {
     "sentence": "sentence",
+    "source_held_out": "source_held_out",
     "verse_metre": "verse",
 }
 BOTTLENECK_TARGET = 100
@@ -170,8 +174,8 @@ def _ordered_unique(values: list[Any]) -> list[Any]:
 def _provenance(row: dict) -> dict:
     keys = (
         "id", "work", "work_id", "cts_urn", "passage", "treebank_source",
-        "book", "poem_sequence", "line_number", "hypotactic_file",
-        "syntax_annotation",
+        "held_out_source", "book", "poem_sequence", "line_number",
+        "hypotactic_file", "syntax_annotation",
     )
     return {key: row.get(key) for key in keys if key in row}
 
@@ -218,6 +222,10 @@ def _aggregate_chunk(base_config: str, rows: list[dict], target: int, split: str
         "conllu": encode_conllu_units([
             unit for row in rows for unit in source_conllu_units(row["conllu"])
         ]),
+        # One audit record per CoNLL-U unit, in the same constituent order.
+        "native_syntax": encode_native_syntax([
+            unit for row in rows for unit in load_native_syntax(row["native_syntax"])
+        ]),
         "cts_urn": rows[0]["cts_urn"] if len({row["cts_urn"] for row in rows}) == 1 else None,
         "passage": (
             rows[0]["passage"]
@@ -243,6 +251,9 @@ def _aggregate_chunk(base_config: str, rows: list[dict], target: int, split: str
         "chunk_is_mixed_work": mixed_work,
     })
 
+    if base_config == "source_held_out":
+        held_out = {row["held_out_source"] for row in rows}
+        assert len(held_out) == 1
     if base_config == "verse_sentence":
         chunk.update({
             "alignment_component_id": None,

scripts/model_facing.py

@@ -0,0 +1,373 @@
+"""Produce the scheme-neutral, identifier-free CoNLL-U that models are given.
+
+Sphragis draws on seven annotation projects whose author inventories do not
+overlap. Every convention that separates those projects therefore separates
+authors as well, and a model can score highly by recognizing the annotator
+instead of the writer. This module reduces every published tree to one shared
+representation and lifts the project-specific material into a separate audit
+column.
+
+The transformation, in order:
+
+* editorial punctuation tokens are removed and the tree is re-indexed, because
+  UD PROIEL does not tokenize punctuation at all and its absence alone
+  identifies its single author;
+* word forms and lemmas are lowercased with ``grc_utils.lower_grc``, because
+  capitalization marks sentence openings and proper nouns inconsistently
+  across projects and editions;
+* XPOS, UPOS, FEATS and DEPREL are collapsed onto the shared inventories in
+  :mod:`syntax_normalization`;
+* MISC is cleared, because ``NativeRel``/``NativeHead``/``HeadRepair`` mark the
+  natively converted projects on every token and ``SpaceAfter`` marks UD
+  Perseus alone;
+* the ``# text`` comment is dropped, because the ``text`` column already
+  carries it.
+
+Everything removed from MISC is returned as a compact ``native_syntax``
+record so the original annotation stays auditable and remappable.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import unicodedata
+from typing import Iterable
+
+from grc_utils import lower_grc, vowel
+
+try:
+    from scripts.syntax_normalization import (
+        CORE_XPOS_POS,
+        CORE_XPOS_TO_UPOS,
+        core_deprel,
+        core_feats,
+        core_upos,
+        core_xpos,
+        is_editorial_punctuation,
+        punctuationless_tokens,
+    )
+except ModuleNotFoundError:  # Direct execution from the scripts directory.
+    from syntax_normalization import (
+        CORE_XPOS_POS,
+        CORE_XPOS_TO_UPOS,
+        core_deprel,
+        core_feats,
+        core_upos,
+        core_xpos,
+        is_editorial_punctuation,
+        punctuationless_tokens,
+    )
+
+
+TOKEN_ID = re.compile(r"\d+")
+AUDIT_MISC_KEYS = ("NativeRel", "NativeHead", "HeadRepair")
+
+
+# Elision is written differently by every project, and the difference alone
+# identifies the source. AGDT and UD Perseus mark it with a trailing combining
+# comma (δ̓, ἀλλ̓); Gorman uses three different apostrophe characters in the same
+# corpus (᾽, ʼ, ’); Pedalion and PROIEL use ’. Stripping the mark leaves the
+# same truncated word form everywhere, which is the only scheme-neutral choice.
+SMOOTH_BREATHING = "\u0313"
+ROUGH_BREATHING = "\u0314"
+KORONIS = "\u0343"
+ELISION_MARKS = frozenset((SMOOTH_BREATHING, ROUGH_BREATHING, KORONIS))
+RHO = "\u03c1"
+
+
+def strip_elision(value: str) -> str:
+    """Remove a word-final elision mark written as a combining breathing.
+
+    A breathing on a vowel is ordinary orthography (ὁ, οὐ, εἰ), so only a
+    trailing mark whose base letter is a consonant can be an elision. Rho is
+    the one consonant that carries a breathing in its own right: the rough
+    breathing of ῥ is kept, while a smooth breathing on rho is the elision
+    convention (ἄῤ for ἄρα). Elided ῥα appears as ῥ̓ in some sources and as ῤ̓
+    in others, so marks are removed to a fixed point rather than one at a
+    time: ῥ̓ keeps the rough breathing rho is entitled to, while ῤ̓ loses both.
+    Reaching a fixed point is what makes this idempotent, which
+    check_model_facing_conllu relies on to verify every published form.
+    """
+    decomposed = unicodedata.normalize("NFD", value)
+    while len(decomposed) > 1 and decomposed[-1] in ELISION_MARKS:
+        base = next(
+            (
+                character for character in reversed(decomposed[:-1])
+                if not unicodedata.combining(character)
+            ),
+            None,
+        )
+        elided = base is not None and not vowel(base) and not (
+            base == RHO and decomposed[-1] == ROUGH_BREATHING
+        )
+        if not elided:
+            break
+        decomposed = decomposed[:-1]
+    return unicodedata.normalize("NFC", decomposed)
+
+
+def normalize_form(value: str) -> str:
+    """Return a word form or lemma in the shared orthography.
+
+    Order matters. Bracketed and hyphenated forms go first, so that an elision
+    mark inside them ([τ̓]) is word-final by the time it is looked for, and NFC
+    goes last, because lowercasing a capital that has no precomposed polytonic
+    form (Ρ̓ῶμε) leaves a decomposed string that would not compare equal to its
+    own normalization.
+    """
+    if not value or value == "_":
+        return value
+    cleaned = "".join(punctuationless_tokens(value))
+    if not cleaned:
+        return value
+    return unicodedata.normalize("NFC", lower_greek(strip_elision(cleaned)))
+
+
+def lower_greek(value: str) -> str:
+    """Lowercase Greek without disturbing ``_`` placeholders or markup.
+
+    ``grc_utils.lower_grc`` handles the precomposed polytonic letters, which
+    ``str.lower`` gets wrong; it does not cover a handful of bare capitals
+    (Ι, Ρ, Ά) or the stray Latin letters a few source files contain, so those
+    fall back to ``str.lower`` character by character.
+    """
+    if not value or value == "_":
+        return value
+    return "".join(
+        character if not character.isupper() else character.lower()
+        for character in lower_grc(value)
+    )
+
+
+def is_punctuation_token(form: str) -> bool:
+    """Decide from the form alone whether a token is editorial punctuation.
+
+    The tag is deliberately not consulted. Some upstream trees have their tag
+    column offset against their forms, so that real words carry ``PUNCT`` and
+    the commas beside them carry word tags; trusting the tag there deletes the
+    words and keeps the commas. A form with no letter or digit in it is
+    punctuation whatever it was tagged.
+    """
+    return not any(character.isalnum() for character in form)
+
+
+def punctuationless_text(text: str) -> str:
+    """Return a text unit in the same orthography as its CoNLL-U forms."""
+    cleaned = "".join(
+        " " if is_editorial_punctuation(character) else character
+        for character in text
+    )
+    return " ".join(strip_elision(word) for word in cleaned.split())
+
+
+def _rows(conllu: str) -> list[list[str]]:
+    rows = []
+    for line in conllu.splitlines():
+        if not line or line.startswith("#"):
+            continue
+        columns = line.split("\t")
+        if len(columns) != 10:
+            raise ValueError(f"CoNLL-U line does not have ten columns: {line!r}")
+        if not TOKEN_ID.fullmatch(columns[0]):
+            raise ValueError(
+                f"published CoNLL-U must contain only integer token rows: {columns[0]!r}"
+            )
+        rows.append(columns)
+    if not rows:
+        raise ValueError("cannot finalize an empty CoNLL-U document")
+    return rows
+
+
+def _native_record(index: int, source_id: int, misc: str) -> dict | None:
+    if not misc or misc == "_":
+        return None
+    values = {}
+    for item in misc.split("|"):
+        key, _, value = item.partition("=")
+        if key in AUDIT_MISC_KEYS:
+            values[key] = value
+    if not values:
+        return None
+    # ``i`` indexes the published token; ``src`` and ``head`` are the source
+    # document's own numbering, which ``NativeHead`` refers to.
+    record = {"i": index, "src": source_id}
+    if "NativeRel" in values:
+        record["rel"] = values["NativeRel"]
+    if "NativeHead" in values:
+        record["head"] = values["NativeHead"]
+    if values.get("HeadRepair") == "Yes":
+        record["repair"] = True
+    return record
+
+
+def finalize_conllu(conllu: str) -> tuple[str, list[dict]]:
+    """Return the model-facing document and its native-annotation audit record.
+
+    Punctuation tokens are dropped and every dependent that hung from one is
+    re-attached to that token's nearest surviving ancestor, so the result is
+    still a single connected tree.
+    """
+    rows = _rows(conllu)
+    by_id = {int(row[0]): row for row in rows}
+    dropped = {int(row[0]) for row in rows if is_punctuation_token(row[1])}
+    kept = [row for row in rows if int(row[0]) not in dropped]
+    if not kept:
+        raise ValueError("removing punctuation left no tokens")
+
+    kept_ids = {int(row[0]) for row in kept}
+
+    def surviving_ancestor(token_id: int) -> int:
+        head = int(by_id[token_id][6])
+        seen = {token_id}
+        while head and head not in kept_ids:
+            if head in seen or head not in by_id:
+                return 0
+            seen.add(head)
+            head = int(by_id[head][6])
+        return head
+
+    resolved = {int(row[0]): surviving_ancestor(int(row[0])) for row in kept}
+    roots = [token_id for token_id, head in resolved.items() if head == 0]
+    primary_root = roots[0] if roots else int(kept[0][0])
+    id_map = {int(row[0]): new_id for new_id, row in enumerate(kept, 1)}
+
+    native: list[dict] = []
+    output: list[str] = []
+    for row in kept:
+        old_id = int(row[0])
+        record = _native_record(id_map[old_id], old_id, row[9])
+        if record is not None:
+            native.append(record)
+
+        head = resolved[old_id]
+        if old_id == primary_root:
+            new_head, relation = 0, "root"
+        else:
+            # A source tree with more than one root, or one whose root was the
+            # punctuation token just removed, still has to publish exactly one.
+            new_head = id_map[head] if head else id_map[primary_root]
+            relation = core_deprel(row[7])
+            if relation in {"root", "punct"}:
+                relation = "dep"
+
+        xpos = core_xpos(row[4])
+        if xpos[0] == "u":
+            # A surviving token tagged as punctuation comes from a tree whose
+            # tag column is offset; its real part of speech is unknown.
+            xpos = "x" + xpos[1:]
+        output.append("\t".join([
+            str(id_map[old_id]),
+            normalize_form(row[1]),
+            normalize_form(row[2]),
+            core_upos(xpos),
+            xpos,
+            core_feats(row[5]),
+            str(new_head),
+            relation,
+            "_",
+            "_",
+        ]))
+    return "\n".join(output) + "\n\n", native
+
+
+def conllu_blocks(unit: str) -> list[str]:
+    """Split a published CoNLL-U unit into its sentence blocks."""
+    return [block for block in unit.split("\n\n") if block.strip()]
+
+
+def finalize_conllu_unit(unit: str) -> tuple[str, list[dict]]:
+    """Finalize every sentence block in one published CoNLL-U unit.
+
+    A Sphragis Metre line can span a sentence boundary, in which case its unit
+    holds two or more blocks, each numbered from 1. They must be finalized
+    separately: merging them would collide their token ids, point heads across
+    a sentence boundary and leave the unit with more than one root. Records
+    from a multi-block unit carry ``b``, the block index, so that ``i`` stays
+    unambiguous.
+    """
+    blocks = conllu_blocks(unit)
+    if not blocks:
+        raise ValueError("cannot finalize an empty CoNLL-U unit")
+    documents = []
+    native: list[dict] = []
+    for index, block in enumerate(blocks):
+        document, block_native = finalize_conllu(block)
+        documents.append(document)
+        for record in block_native:
+            native.append(
+                {**record, "b": index} if len(blocks) > 1 else record
+            )
+    return "".join(documents), native
+
+
+def encode_native_syntax(units: Iterable[list[dict]]) -> str:
+    """Serialize the per-unit native annotation audit records."""
+    return json.dumps(list(units), ensure_ascii=False)
+
+
+def load_native_syntax(encoded: str) -> list[list[dict]]:
+    """Load the native annotation audit column as one record list per unit."""
+    units = json.loads(encoded)
+    if not isinstance(units, list):
+        raise ValueError("native_syntax must encode a JSON list")
+    for unit in units:
+        if not isinstance(unit, list) or not all(
+            isinstance(record, dict) for record in unit
+        ):
+            raise ValueError("every native_syntax unit must be a list of records")
+    return units
+
+
+CORE_UPOS = frozenset(CORE_XPOS_TO_UPOS.values()) - {"PUNCT"}
+
+
+def check_model_facing_conllu(conllu: str, where: str) -> None:
+    """Assert every invariant the model-facing representation guarantees.
+
+    Each of these removes a channel through which the annotating project, and
+    therefore the author, could be recognized without reading the Greek.
+    """
+    assert not any(
+        line.startswith("#") for line in conllu.splitlines()
+    ), f"{where}: CoNLL-U comments are not published; the text column carries the text"
+    blocks = conllu_blocks(conllu)
+    assert blocks, f"{where}: CoNLL-U unit contains no sentence block"
+    for index, block in enumerate(blocks):
+        _check_block(block, f"{where}, block {index}")
+
+
+def _check_block(conllu: str, where: str) -> None:
+    seen_ids = []
+    heads = []
+    for line in conllu.splitlines():
+        if not line:
+            continue
+        columns = line.split("\t")
+        assert len(columns) == 10, f"{where}: expected ten columns, got {len(columns)}"
+        token_id, form, lemma, upos, xpos, feats, head, relation, deps, misc = columns
+        assert TOKEN_ID.fullmatch(token_id), f"{where}: non-integer token id {token_id!r}"
+        seen_ids.append(int(token_id))
+        heads.append(int(head))
+        assert misc == "_", f"{where}: MISC identifies the source project ({misc!r})"
+        assert deps == "_", f"{where}: DEPS is not published ({deps!r})"
+        assert upos in CORE_UPOS, f"{where}: UPOS {upos!r} is outside the shared inventory"
+        assert xpos != "_" and len(xpos) == 9, f"{where}: XPOS must be nine positions"
+        assert xpos[0] in CORE_XPOS_POS and CORE_XPOS_POS[xpos[0]] == xpos[0], (
+            f"{where}: XPOS part of speech {xpos[0]!r} is outside the shared inventory"
+        )
+        assert xpos[0] != "u", f"{where}: punctuation tokens are not published"
+        assert core_deprel(relation) == relation and relation != "punct", (
+            f"{where}: DEPREL {relation!r} is outside the shared inventory"
+        )
+        assert core_feats(feats) == feats, (
+            f"{where}: FEATS {feats!r} is outside the shared inventory"
+        )
+        for column, name in ((form, "FORM"), (lemma, "LEMMA")):
+            if column == "_":
+                continue
+            assert column == normalize_form(column), (
+                f"{where}: {name} {column!r} is not in the shared orthography"
+            )
+    assert seen_ids == list(range(1, len(seen_ids) + 1)), f"{where}: token ids are not contiguous"
+    assert heads.count(0) == 1, f"{where}: expected exactly one root, got {heads.count(0)}"

scripts/syntax_normalization.py

@@ -74,3 +74,96 @@ def canonical_stoicheia_deprel(relation: str | None, upos: str, head: int) -> st
 
 def is_universal_deprel(relation: str) -> bool:
     return relation.split(":", 1)[0] in UNIVERSAL_DEPRELS
+
+
+# ---------------------------------------------------------------------------
+# Scheme-neutral model-facing normalization.
+#
+# Sphragis merges seven annotation projects whose author inventories do not
+# overlap, so any convention that distinguishes those projects also identifies
+# the author. The mappings below reduce every source to one shared inventory,
+# so that a category boundary the projects disagree about cannot be used as an
+# authorship feature. See metadata/leakage_report.json for the measured effect.
+# ---------------------------------------------------------------------------
+
+# AGDT nine-position part of speech (XPOS position 1) after normalization.
+# ``l``/``p`` (article, pronoun) and ``d``/``g``/``c``/``b`` (adverb, particle,
+# conjunction) are merged because the projects disagree about exactly these
+# boundaries for the highest-frequency Greek function words: δέ is a particle
+# in AGDT, an adverb in Gorman and a coordinator in UD Perseus; καί is a
+# subordinator in the AGDT lineage and a coordinator in UD.
+CORE_XPOS_POS = {
+    "n": "n", "v": "v", "t": "v", "a": "a",
+    "p": "p", "l": "p",
+    "d": "d", "g": "d", "c": "d", "b": "d",
+    "r": "r", "m": "m", "i": "i",
+    "u": "u",
+    "x": "x", "e": "x", "z": "x", "-": "x",
+}
+
+CORE_XPOS_TO_UPOS = {
+    "n": "NOUN", "v": "VERB", "a": "ADJ", "p": "PRON", "d": "ADV",
+    "r": "ADP", "m": "NUM", "i": "INTJ", "u": "PUNCT", "x": "X",
+}
+
+# Morphological features every source project expresses. ``VerbForm`` is
+# dropped because it is absent from all natively converted trees and is already
+# carried uniformly by XPOS position 5; ``PronType``, ``Definite``, ``Aspect``,
+# ``Polarity``, ``Poss`` and ``Reflex`` occur in one project only.
+CORE_FEATS = ("Case", "Degree", "Gender", "Mood", "Number", "Person", "Tense", "Voice")
+
+# Shared dependency inventory. Relations are merged wherever the projects
+# express one analysis with different labels: ``det`` joins the attributive
+# bucket because the AGDT lineage annotates the article as an attribute, and
+# ``cc``/``cop``/``aux`` join the functional bucket because native schemes
+# never produce them.
+CORE_DEPREL = {
+    "root": "root",
+    "nsubj": "nsubj", "csubj": "nsubj",
+    "obj": "obj", "iobj": "obj",
+    "ccomp": "ccomp", "xcomp": "ccomp",
+    "obl": "obl",
+    "nmod": "nmod", "amod": "nmod", "nummod": "nmod", "det": "nmod",
+    "advmod": "advmod", "acl": "advmod", "advcl": "advmod",
+    "case": "case", "mark": "case", "cc": "case", "cop": "case", "aux": "case",
+    "conj": "conj",
+    "appos": "appos",
+    "vocative": "vocative",
+    "discourse": "discourse", "dislocated": "discourse",
+    "punct": "punct",
+}
+
+CORE_DEPRELS = frozenset(CORE_DEPREL.values()) | {"dep"}
+
+
+def core_deprel(relation: str) -> str:
+    """Collapse a relation onto the inventory every source project shares."""
+    base = (relation or "dep").split(":", 1)[0].lower()
+    return CORE_DEPREL.get(base, "dep")
+
+
+def core_feats(feats: str) -> str:
+    """Retain only the morphological features every source project expresses."""
+    if not feats or feats == "_":
+        return "_"
+    retained = [
+        item for item in feats.split("|")
+        if item.split("=", 1)[0] in CORE_FEATS
+    ]
+    return "|".join(sorted(retained)) or "_"
+
+
+def core_xpos(xpos: str) -> str:
+    """Merge the part-of-speech position onto the shared inventory."""
+    if not xpos or xpos == "_":
+        return xpos
+    if len(xpos) != 9:
+        raise ValueError(f"XPOS must have exactly nine positions, got {xpos!r}")
+    return CORE_XPOS_POS.get(xpos[0], "x") + xpos[1:]
+
+
+def core_upos(xpos: str) -> str:
+    """Derive UPOS from the normalized XPOS so both columns share one scheme."""
+    if not xpos or xpos == "_":
+        return "X"
+    return CORE_XPOS_TO_UPOS.get(CORE_XPOS_POS.get(xpos[0], "x"), "X")

scripts/validate_publication.py

@@ -14,6 +14,7 @@ import unicodedata
 
 import pyarrow.parquet as pq
 
+
 try:
     from scripts.conllu_units import load_conllu_units
     from scripts.metre_units import load_metre_units, load_syllable_units
@@ -23,6 +24,12 @@ try:
         is_universal_deprel,
         syntax_text_normalize,
     )
+    from scripts.model_facing import (
+        check_model_facing_conllu,
+        conllu_blocks,
+        load_native_syntax,
+        lower_greek,
+    )
     from scripts.vendor.conll18_ud_eval import UDError, load_conllu
 except ModuleNotFoundError:
     from conllu_units import load_conllu_units
@@ -33,11 +40,42 @@ except ModuleNotFoundError:
         is_universal_deprel,
         syntax_text_normalize,
     )
+    from model_facing import (
+        check_model_facing_conllu,
+        conllu_blocks,
+        load_native_syntax,
+        lower_greek,
+    )
     from vendor.conll18_ud_eval import UDError, load_conllu
 
 
 SPLITS = ("train", "validation", "test")
-SAFE_MISC_KEYS = {"NativeRel", "NativeHead", "HeadRepair", "SpaceAfter"}
+
+
+def check_source_held_out(config: str, rows: list[dict]) -> None:
+    """Assert no author is evaluated on an annotation project it trained on."""
+    by_author: dict[str, dict[str, set[str]]] = {}
+    for row in rows:
+        provenance = row.get("constituent_provenance")
+        sources = (
+            {
+                record["treebank_source"]
+                for record in json.loads(provenance)
+                if record.get("treebank_source")
+            }
+            if provenance
+            else {row["treebank_source"]}
+        )
+        splits = by_author.setdefault(row["author"], {})
+        splits.setdefault(row["split"], set()).update(sources)
+        splits.setdefault("held_out", set()).add(row["held_out_source"])
+    for author, splits in sorted(by_author.items()):
+        assert len(splits["held_out"]) == 1, (config, author, splits["held_out"])
+        held_out = next(iter(splits["held_out"]))
+        evaluation = splits.get("validation", set()) | splits.get("test", set())
+        assert evaluation == {held_out}, (config, author, sorted(evaluation), held_out)
+        assert held_out not in splits.get("train", set()), (config, author, held_out)
+        assert splits.get("train"), (config, author)
 
 
 def normalize(value: str) -> str:
@@ -51,9 +89,13 @@ def normalize(value: str) -> str:
 
 
 def configs(publication: str) -> tuple[str, ...]:
-    base = "sentence" if publication == "sentence" else "verse"
     suffixes = (1, 10, 50, 100)
-    return tuple(f"{base}_{suffix}" for suffix in suffixes)
+    if publication == "sentence":
+        return (
+            *(f"sentence_{suffix}" for suffix in suffixes),
+            *(f"source_held_out_{suffix}" for suffix in suffixes),
+        )
+    return tuple(f"verse_{suffix}" for suffix in suffixes)
 
 
 def read_config(root: Path, config: str) -> list[dict]:
@@ -71,30 +113,25 @@ def read_config(root: Path, config: str) -> list[dict]:
 
 
 def validate_conllu(config: str, row: dict, checked: set[bytes]) -> None:
-    for conllu in load_conllu_units(row["conllu"]):
-        comments = [line for line in conllu.splitlines() if line.startswith("#")]
-        assert all(line.startswith("# text = ") for line in comments)
-        for line in conllu.splitlines():
-            if not line or line.startswith("#"):
-                continue
-            columns = line.split("\t")
-            assert len(columns) == 10
-            if config.startswith("verse_"):
-                assert is_universal_deprel(columns[7])
-                assert not any(
-                    is_editorial_punctuation(character) for character in columns[1]
-                )
-                assert columns[2] == "_" or not any(
-                    is_editorial_punctuation(character) for character in columns[2]
-                )
-            misc_keys = {
-                item.split("=", 1)[0]
-                for item in columns[9].split("|")
-                if item != "_"
+    text_units = load_text_units(row["text"])
+    native_units = load_native_syntax(row["native_syntax"])
+    conllu_units = load_conllu_units(row["conllu"])
+    assert len(native_units) == len(conllu_units)
+    for index, conllu in enumerate(conllu_units):
+        check_model_facing_conllu(conllu, f"{config}, row {row['id']}")
+        forms = "".join(
+            line.split("\t")[1] for line in conllu.splitlines() if line
+        )
+        assert syntax_text_normalize(forms) == syntax_text_normalize(text_units[index])
+        blocks = [
+            {
+                int(line.split("\t")[0]) for line in block.splitlines() if line
             }
-            assert misc_keys <= SAFE_MISC_KEYS
-            if config.startswith("verse_"):
-                assert misc_keys <= {"HeadRepair"}
+            for block in conllu_blocks(conllu)
+        ]
+        for record in native_units[index]:
+            block = blocks[record.get("b", 0)]
+            assert record["i"] in block, (config, row["id"], record)
         digest = hashlib.sha256(conllu.encode("utf-8")).digest()
         if digest in checked:
             continue
@@ -172,6 +209,16 @@ def main() -> None:
                         and re.fullmatch(r"\d+", line.split("\t", 1)[0])
                     )
                     assert syntax_text_normalize(forms) == syntax_text_normalize(text)
+        for row in rows:
+            for unit in load_text_units(row["text"]):
+                assert unit == lower_greek(unit), (
+                    f"{config}, row {row['id']}: text is not lowercased"
+                )
+                assert not any(
+                    is_editorial_punctuation(character) for character in unit
+                ), f"{config}, row {row['id']}: text retains editorial punctuation"
+        if config.startswith("source_held_out"):
+            check_source_held_out(config, rows)
         print(config, len(rows), dict(Counter(row["split"] for row in rows)))
 
     atomic = rows_by_config[expected_configs[0]]
@@ -191,17 +238,23 @@ def main() -> None:
             "derived boundary feature author coverage",
             {feature: len(covered) for feature, covered in feature_authors.items()},
         )
-    for config in expected_configs[1:]:
-        for split in SPLITS:
-            expected_ids = {row["id"] for row in atomic if row["split"] == split}
-            represented_ids = [
-                constituent_id
-                for row in rows_by_config[config]
-                if row["split"] == split
-                for constituent_id in row["constituent_ids"]
-            ]
-            assert len(represented_ids) == len(set(represented_ids))
-            assert set(represented_ids) == expected_ids
+    for track in sorted({config.rsplit("_", 1)[0] for config in expected_configs}):
+        track_atomic = rows_by_config[f"{track}_1"]
+        for config in expected_configs:
+            if config == f"{track}_1" or not config.startswith(f"{track}_"):
+                continue
+            for split in SPLITS:
+                expected_ids = {
+                    row["id"] for row in track_atomic if row["split"] == split
+                }
+                represented_ids = [
+                    constituent_id
+                    for row in rows_by_config[config]
+                    if row["split"] == split
+                    for constituent_id in row["constituent_ids"]
+                ]
+                assert len(represented_ids) == len(set(represented_ids))
+                assert set(represented_ids) == expected_ids
 
     print("validated unique CoNLL-U documents", len(checked_conllu))
     print("all publication checks passed")

slurm/rebuild_dataset.slurm

@@ -48,6 +48,13 @@ srun --kill-on-bad-exit=1 "$python" -u scripts/build_dataset.py \
   --metre-output "$metre_stage/data" --metre-metadata "$metre_stage/metadata" \
   --stoicheia-conllu "$stoicheia_conllu"
 
+# scripts/audit_leakage.py is the only build step that needs scikit-learn.
+"$python" -m pip install --quiet --disable-pip-version-check "scikit-learn>=1.4"
+
+echo "[$(date --iso-8601=seconds)] measuring residual scheme-only leakage on the staged data"
+srun --kill-on-bad-exit=1 "$python" -u scripts/audit_leakage.py \
+  --data "$stage/data" --metadata "$stage/metadata"
+
 echo "[$(date --iso-8601=seconds)] independently validating both staged publications"
 srun --kill-on-bad-exit=1 "$python" -u scripts/validate_publication.py \
   --publication sentence --data "$stage/data"

tests/test_conllu_well_formed.py

@@ -12,6 +12,7 @@ from scripts.syntax_normalization import (
     is_universal_deprel,
     syntax_text_normalize,
 )
+from scripts.model_facing import check_model_facing_conllu
 
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
@@ -19,9 +20,9 @@ DATA_ROOT = REPO_ROOT / "data"
 METRE_DATA_ROOT = REPO_ROOT.parent / "sphragis-metre" / "data"
 CONFIGS = tuple(
     [(DATA_ROOT, f"sentence_{suffix}") for suffix in ("1", "10", "50", "100")]
+    + [(DATA_ROOT, f"source_held_out_{suffix}") for suffix in ("1", "10", "50", "100")]
     + [(METRE_DATA_ROOT, f"verse_{suffix}") for suffix in ("1", "10", "50", "100")]
 )
-SAFE_MISC_KEYS = {"NativeRel", "NativeHead", "HeadRepair", "SpaceAfter"}
 
 
 def test_all_conllu_documents_are_well_formed_and_identifier_free() -> None:
@@ -37,43 +38,9 @@ def test_all_conllu_documents_are_well_formed_and_identifier_free() -> None:
                 for row in batch.to_pylist():
                     conllu_units = load_conllu_units(row["conllu"])
                     for conllu in conllu_units:
-                        comments = [
-                            line for line in conllu.splitlines()
-                            if line.startswith("#")
-                        ]
-                        assert all(line.startswith("# text = ") for line in comments), (
-                            config,
-                            split,
-                            row["id"],
-                            comments,
+                        check_model_facing_conllu(
+                            conllu, f"{config}/{split}, row {row['id']}",
                         )
-                        for line in conllu.splitlines():
-                            if not line or line.startswith("#"):
-                                continue
-                            columns = line.split("\t")
-                            assert len(columns) == 10
-                            misc_keys = {
-                                item.split("=", 1)[0]
-                                for item in columns[9].split("|")
-                                if item != "_"
-                            }
-                            assert misc_keys <= SAFE_MISC_KEYS, (
-                                config,
-                                split,
-                                row["id"],
-                                misc_keys,
-                            )
-                            if config.startswith("verse_"):
-                                assert misc_keys <= {"HeadRepair"}
-                                assert is_universal_deprel(columns[7])
-                                assert not any(
-                                    is_editorial_punctuation(character)
-                                    for character in columns[1]
-                                )
-                                assert columns[2] == "_" or not any(
-                                    is_editorial_punctuation(character)
-                                    for character in columns[2]
-                                )
                         digest = hashlib.sha256(conllu.encode("utf-8")).digest()
                         if digest in checked:
                             continue

tests/test_model_facing.py

@@ -0,0 +1,342 @@
+"""The scheme-neutral representation is the benchmark's anti-leakage guarantee.
+
+Sphragis merges seven annotation projects whose author inventories do not
+overlap, so any convention that separates the projects also separates authors.
+These tests pin the transformation that removes those conventions.
+"""
+
+import json
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import pytest
+
+from scripts.model_facing import (
+    check_model_facing_conllu,
+    conllu_blocks,
+    finalize_conllu,
+    finalize_conllu_unit,
+    lower_greek,
+    normalize_form,
+    punctuationless_text,
+)
+from scripts.syntax_normalization import core_deprel, core_feats, core_upos, core_xpos
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DATA_ROOT = REPO_ROOT / "data"
+
+NATIVE_DOCUMENT = (
+    "# text = Ἀλλὰ καί, ὦ φίλε.\n"
+    "1\tἈλλὰ\tἀλλά\tPART\tg--------\t_\t3\tadvmod\t_\tNativeRel=AuxY|NativeHead=3\n"
+    "2\tκαί\tκαί\tSCONJ\tc--------\t_\t3\tcc\t_\tNativeRel=AuxC|NativeHead=3|HeadRepair=Yes\n"
+    "3\t,\t,\tPUNCT\tu--------\t_\t5\tpunct\t_\t_\n"
+    "4\tὦ\tὦ\tINTJ\ti--------\t_\t5\tdiscourse\t_\tNativeRel=AuxZ|NativeHead=5\n"
+    "5\tφίλε\tφίλος\tNOUN\tn-s---mv-\tCase=Voc|Gender=Masc|Number=Sing|VerbForm=Fin"
+    "\t0\troot\t_\tSpaceAfter=No\n"
+    "6\t.\t.\tPUNCT\tu--------\t_\t5\tpunct\t_\t_\n"
+)
+
+
+def test_finalize_removes_every_source_identifying_channel() -> None:
+    document, native = finalize_conllu(NATIVE_DOCUMENT)
+    check_model_facing_conllu(document, "unit test")
+    rows = [line.split("\t") for line in document.splitlines() if line]
+    assert [row[0] for row in rows] == ["1", "2", "3", "4"], "punctuation is dropped"
+    assert [row[1] for row in rows] == ["ἀλλὰ", "καί", "ὦ", "φίλε"]
+    assert all(row[9] == "_" for row in rows), "MISC identifies the project"
+    assert "VerbForm" not in document, "VerbForm is absent from native schemes"
+    assert not document.startswith("#"), "the text column carries the text"
+    # The head of token 1 was 3, which was punctuation; it re-attaches to the
+    # punctuation token's own surviving ancestor rather than dangling.
+    assert rows[0][6] == "4"
+    assert [record["src"] for record in native] == [1, 2, 4]
+    assert native[1] == {"i": 2, "src": 2, "rel": "AuxC", "head": "3", "repair": True}
+
+
+def test_exactly_one_root_survives_a_multi_root_source_tree() -> None:
+    document, _ = finalize_conllu(
+        "1\tἀρχόμενος\tἄρχω\tVERB\tv-sppemn-\t_\t0\troot\t_\t_\n"
+        "2\tσέο\tσύ\tPRON\tp-s---mg-\t_\t1\tobj\t_\t_\n"
+        "3\tΦοῖβε\tΦοῖβος\tNOUN\tn-s---mv-\t_\t0\troot\t_\t_\n"
+    )
+    check_model_facing_conllu(document, "unit test")
+    rows = [line.split("\t") for line in document.splitlines() if line]
+    assert [row[6] for row in rows] == ["0", "1", "1"]
+    assert [row[7] for row in rows] == ["root", "obj", "dep"]
+
+
+def test_a_root_that_was_punctuation_hands_the_root_on() -> None:
+    document, _ = finalize_conllu(
+        "1\tκαλός\tκαλός\tADJ\ta-s---mn-\t_\t2\tamod\t_\t_\n"
+        "2\t.\t.\tPUNCT\tu--------\t_\t0\troot\t_\t_\n"
+    )
+    check_model_facing_conllu(document, "unit test")
+    assert document.split("\t")[6:8] == ["0", "root"]
+
+
+def test_a_misaligned_tag_column_never_deletes_a_real_word() -> None:
+    """Some upstream trees have their tags offset by one against their forms.
+
+    In this AGDT sentence the commas carry word tags and the words beside them
+    carry PUNCT, so a filter that trusts the tag deletes ὦ and τὸν and keeps
+    the commas. Punctuation is decided from the form instead.
+    """
+    document, _ = finalize_conllu(
+        "1\tγιγνώσκω\tγιγνώσκω\tADV\td--------\t_\t0\troot\t_\t_\n"
+        "2\t,\t,\tADV\td--------\t_\t1\tadvmod\t_\t_\n"
+        "3\tὦ\tὦ\tPUNCT\tu--------\t_\t1\tpunct\t_\t_\n"
+        "4\tτὸν\tὁ\tPUNCT\tu--------\t_\t5\tpunct\t_\t_\n"
+        "5\tἄνδρα\tἀνήρ\tDET\tl-s---ma-\t_\t1\tobj\t_\t_\n"
+    )
+    check_model_facing_conllu(document, "unit test")
+    rows = [line.split("\t") for line in document.splitlines() if line]
+    assert [row[1] for row in rows] == ["γιγνώσκω", "ὦ", "τὸν", "ἄνδρα"]
+    # A word that survives while still tagged as punctuation has no reliable
+    # part of speech, so it is published as X rather than as PUNCT. The other
+    # tags stay as the offset annotation left them: UPOS is derived from XPOS,
+    # so γιγνώσκω keeps the adverb tag it was wrongly given upstream.
+    assert [row[3] for row in rows] == ["ADV", "X", "X", "PRON"]
+    assert all(row[4][0] != "u" for row in rows)
+
+
+def test_a_numeral_written_with_digits_is_not_treated_as_punctuation() -> None:
+    document, _ = finalize_conllu(
+        "1\tἔτη\tἔτος\tNOUN\tn-p---na-\t_\t0\troot\t_\t_\n"
+        "2\t12\t12\tNUM\tm--------\t_\t1\tnummod\t_\t_\n"
+        "3\t.\t.\tPUNCT\tu--------\t_\t1\tpunct\t_\t_\n"
+    )
+    rows = [line.split("\t") for line in document.splitlines() if line]
+    assert [row[1] for row in rows] == ["ἔτη", "12"]
+
+
+MULTI_BLOCK_UNIT = (
+    "# text = μοῖραν ἀνέπλησεν\n"
+    "1\tμοῖραν\tμοῖρα\tNOUN\tn-s---fa-\t_\t2\tobj\t_\t_\n"
+    "2\tἀνέπλησεν\tἀίμπλημι\tVERB\tv3saia---\t_\t0\troot\t_\tHeadRepair=Yes\n"
+    "\n"
+    "# text = τὴν γὰρ θέμις\n"
+    "1\tτὴν\tὁ\tPRON\tp-s---fa-\t_\t3\tobj\t_\t_\n"
+    "2\tγὰρ\tγάρ\tPART\tg--------\t_\t0\troot\t_\tHeadRepair=Yes\n"
+    "3\tθέμις\tθέμις\tNOUN\tn-s---fn-\t_\t2\tnsubj\t_\t_\n"
+)
+
+
+def test_a_line_spanning_a_sentence_boundary_keeps_its_blocks_apart() -> None:
+    """A Sphragis Metre line can hold two sentence blocks, each numbered from 1.
+
+    Merging them collides the token ids, points heads across the sentence
+    boundary and leaves two roots in one tree, so each block is finalized on
+    its own and the unit keeps its block structure.
+    """
+    document, native = finalize_conllu_unit(MULTI_BLOCK_UNIT)
+    check_model_facing_conllu(document, "unit test")
+    blocks = conllu_blocks(document)
+    assert len(blocks) == 2
+    for block in blocks:
+        rows = [line.split("\t") for line in block.splitlines() if line]
+        assert [row[0] for row in rows] == [
+            str(n) for n in range(1, len(rows) + 1)
+        ]
+        assert sum(row[6] == "0" for row in rows) == 1
+    # ``b`` disambiguates ``i``, which restarts in every block.
+    assert native == [
+        {"i": 2, "src": 2, "repair": True, "b": 0},
+        {"i": 2, "src": 2, "repair": True, "b": 1},
+    ]
+
+
+def test_a_single_block_unit_carries_no_block_index() -> None:
+    _, native = finalize_conllu_unit(
+        "1\tλόγος\tλόγος\tNOUN\tn-s---mn-\t_\t0\troot\t_\tNativeRel=PRED\n"
+    )
+    assert native == [{"i": 1, "src": 1, "rel": "PRED"}]
+
+
+def test_a_tree_that_is_entirely_punctuation_is_rejected() -> None:
+    with pytest.raises(ValueError):
+        finalize_conllu("1\t,\t,\tPUNCT\tu--------\t_\t0\troot\t_\t_\n")
+
+
+@pytest.mark.parametrize(
+    "source, expected",
+    [
+        # δέ is a particle in AGDT, an adverb in Gorman, a coordinator in UD.
+        ("PART", "ADV"), ("CCONJ", "ADV"), ("SCONJ", "ADV"), ("ADV", "ADV"),
+        # The article is DET in UD and a pronoun in the AGDT lineage.
+        ("DET", "PRON"), ("PRON", "PRON"),
+        # εἰμί is AUX only in the UD conversions.
+        ("AUX", "VERB"), ("VERB", "VERB"),
+        # PROPN occurs in PROIEL alone, which supplies exactly one author.
+        ("PROPN", "NOUN"), ("NOUN", "NOUN"),
+    ],
+)
+def test_upos_categories_the_projects_disagree_about_are_merged(
+    source: str, expected: str,
+) -> None:
+    xpos = {
+        "PART": "g", "CCONJ": "b", "SCONJ": "c", "ADV": "d",
+        "DET": "l", "PRON": "p", "AUX": "v", "VERB": "v",
+        "PROPN": "n", "NOUN": "n",
+    }[source] + "--------"
+    assert core_upos(xpos) == expected
+
+
+@pytest.mark.parametrize(
+    "source, expected",
+    [
+        # cc, cop and aux are never produced by the native conversions.
+        ("cc", "case"), ("cop", "case"), ("aux", "case"), ("case", "case"),
+        ("mark", "case"),
+        # iobj occurs in UD Perseus alone.
+        ("iobj", "obj"), ("obj", "obj"),
+        # PROIEL is the only source with subtyped relations.
+        ("nsubj:pass", "nsubj"), ("obl:arg", "obl"), ("advcl:cmp", "advmod"),
+        # The two conversions of the same AGDT trees disagree here.
+        ("amod", "nmod"), ("nmod", "nmod"), ("det", "nmod"),
+        ("dislocated", "discourse"), ("discourse", "discourse"),
+        ("orphan", "dep"), ("flat:name", "dep"), ("parataxis", "dep"),
+    ],
+)
+def test_deprels_the_projects_disagree_about_are_merged(
+    source: str, expected: str,
+) -> None:
+    assert core_deprel(source) == expected
+
+
+def test_feats_are_restricted_to_the_shared_inventory() -> None:
+    assert core_feats(
+        "Aspect=Imp|Case=Nom|Definite=Def|Gender=Masc|PronType=Dem|VerbForm=Fin"
+    ) == "Case=Nom|Gender=Masc"
+    assert core_feats("_") == "_"
+    assert core_feats("VerbForm=Fin") == "_"
+
+
+def test_greek_is_lowercased_including_what_lower_grc_leaves() -> None:
+    assert lower_greek("Ἀλλά") == "ἀλλά"
+    assert lower_greek("ΙΡΆ") == "ιρά"
+    assert lower_greek("_") == "_"
+
+
+@pytest.mark.parametrize(
+    "source, expected",
+    [
+        # Every project writes elision differently, and the difference alone
+        # identifies the source: AGDT and UD Perseus use a combining comma,
+        # Gorman uses three apostrophes in one corpus, Pedalion and PROIEL use
+        # the right single quote.
+        ("ἀλλ\u0313", "ἀλλ"), ("ἀλλ’", "ἀλλ"), ("ἀλλʼ", "ἀλλ"), ("ἀλλ᾽", "ἀλλ"),
+        ("δ\u0313", "δ"), ("χέρσ\u0313", "χέρσ"), ("ἄῤ", "ἄρ"),
+        # A breathing on a vowel is ordinary orthography, not elision.
+        ("ὁ", "ὁ"), ("ἡ", "ἡ"), ("οὐ", "οὐ"), ("οἱ", "οἱ"), ("εἰ", "εἰ"),
+        # Rho is the one consonant that carries a breathing in its own right.
+        # Elided ῥα is written ῥ̓, two marks on one rho, and loses only the
+        # second; a smooth breathing on rho is itself the elision (ἄῤ = ἄρα).
+        ("ῥ\u0313", "ῥ"), ("ῥ", "ῥ"), ("ῥόδον", "ῥόδον"), ("ῤ", "ρ"),
+        # ῥα is elided as ῥ̓ in some sources and ῤ̓ in others; marks come off to
+        # a fixed point, so the doubled smooth breathing loses both.
+        ("ῤ\u0313", "ρ"),
+        # Gorman hyphenates and AGDT brackets; neither is a scheme-neutral fact.
+        ("κατα-βαίνω", "καταβαίνω"), ("[τι]", "τι"),
+        # Punctuation comes off first, so an elision mark inside brackets is
+        # word-final by the time it is looked for.
+        ("[τ\u0313]", "τ"),
+        # Lowercasing a capital with no precomposed polytonic form leaves a
+        # decomposed string, so NFC is reapplied last.
+        ("Ρ\u0313ῶμε", "ῤῶμε"),
+        ("Ἀλλά", "ἀλλά"), ("_", "_"),
+    ],
+)
+def test_word_forms_reach_one_shared_orthography(source: str, expected: str) -> None:
+    assert normalize_form(source) == expected
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        "ῥ\u0313", "ῥ", "ῤ", "ῤ\u0313", "ῥ\u0313\u0313", "ἄῤ", "δ\u0313",
+        "ἀλλ’", "ἀλλ\u0313", "ὁ", "οὐ", "εἰ", "οἱ", "ἐπ\u0313",
+        "χέρσ\u0313", "ῥόδον", "ἄνθρωπος", "κατα-βαίνω", "[τι]", "[τ\u0313]",
+        "Ρ\u0313ῶμε", "Ἀλλά",
+    ],
+)
+def test_normalizing_a_word_form_twice_changes_nothing(source: str) -> None:
+    """check_model_facing_conllu re-normalizes to verify, so this must hold."""
+    once = normalize_form(source)
+    assert normalize_form(once) == once
+
+
+def test_editorial_punctuation_leaves_the_text_column() -> None:
+    assert punctuationless_text("ἀλλὰ καί, ὦ φίλε.") == "ἀλλὰ καί ὦ φίλε"
+    assert punctuationless_text("ἀλλ’ ὁ ἀνήρ, οὐ δ\u0313 ἔστιν.") == "ἀλλ ὁ ἀνήρ οὐ δ ἔστιν"
+
+
+def _configs(prefix: str) -> list[str]:
+    return [f"{prefix}_{suffix}" for suffix in ("1", "10", "50", "100")]
+
+
+@pytest.mark.parametrize("config", _configs("source_held_out"))
+def test_no_author_is_evaluated_on_an_annotator_it_trained_on(config: str) -> None:
+    """The whole point of the track: the evaluation scheme is unseen in training."""
+    sources: dict[str, dict[str, set[str]]] = {}
+    held_out: dict[str, set[str]] = {}
+    for split in ("train", "validation", "test"):
+        path = DATA_ROOT / config / f"{split}-00000-of-00001.parquet"
+        columns = ["author", "treebank_source", "held_out_source"]
+        if config != "source_held_out_1":
+            columns.append("constituent_provenance")
+        for row in pq.read_table(path, columns=columns).to_pylist():
+            provenance = row.get("constituent_provenance")
+            row_sources = (
+                {
+                    record["treebank_source"]
+                    for record in json.loads(provenance)
+                    if record.get("treebank_source")
+                }
+                if provenance
+                else {row["treebank_source"]}
+            )
+            sources.setdefault(row["author"], {}).setdefault(split, set()).update(
+                row_sources
+            )
+            held_out.setdefault(row["author"], set()).add(row["held_out_source"])
+
+    assert sources, config
+    for author, by_split in sorted(sources.items()):
+        assert held_out[author] == {next(iter(held_out[author]))}
+        source = next(iter(held_out[author]))
+        evaluation = by_split.get("validation", set()) | by_split.get("test", set())
+        assert evaluation == {source}, (config, author, sorted(evaluation))
+        assert source not in by_split.get("train", set()), (config, author)
+        assert by_split.get("train"), (config, author)
+
+
+def test_chunking_keeps_one_audit_record_per_conllu_unit() -> None:
+    """Every column that is a per-unit list has to be merged when chunking."""
+    from scripts.conllu_units import load_conllu_units
+    from scripts.dataset_variants import _aggregate_chunk
+    from scripts.model_facing import encode_native_syntax, load_native_syntax
+    from scripts.text_units import encode_text_units
+
+    def row(index: int) -> dict:
+        document, native = finalize_conllu(
+            f"1\tλόγος{index}\tλόγος\tNOUN\tn-s---mn-\t_\t0\troot\t_\tNativeRel=PRED\n"
+        )
+        return {
+            "id": f"s-{index:04d}", "author": "Plato", "work": "Gorgias",
+            "work_id": "tlg0059.tlg023", "genre": "prose", "split": "train",
+            "text": encode_text_units([f"λόγος{index}"]),
+            "conllu": json.dumps([document], ensure_ascii=False),
+            "native_syntax": encode_native_syntax([native]),
+            "cts_urn": "", "passage": "", "treebank_source": "agdt",
+            "source_records": "[]", "licenses": ["CC-BY-SA-3.0-US"],
+            "dedup_key": f"k{index}",
+        }
+
+    rows = [row(index) for index in range(10)]
+    chunk = _aggregate_chunk("sentence", rows, 10, "train")
+    assert len(load_conllu_units(chunk["conllu"])) == 10
+    assert len(load_native_syntax(chunk["native_syntax"])) == 10
+    assert load_native_syntax(chunk["native_syntax"])[3] == [
+        {"i": 1, "src": 1, "rel": "PRED"}
+    ]

tests/test_split_stratification.py

@@ -23,8 +23,15 @@ METRE_ROOT = REPO_ROOT.parent / "sphragis-metre"
 SPLITS = ("train", "validation", "test")
 PUBLICATIONS = (
     (REPO_ROOT, "sentence", (1, 10, 50, 100)),
+    (REPO_ROOT, "source_held_out", (1, 10, 50, 100)),
     (METRE_ROOT, "verse", (1, 10, 50, 100)),
 )
+# The per-author unit table in each README documents the main track only; the
+# source-held-out track's per-author counts live in build_report.json, because
+# two tables of the same shape in one README cannot be told apart by pattern.
+README_AUTHOR_TABLES = tuple(
+    publication for publication in PUBLICATIONS if publication[1] != "source_held_out"
+)
 TREEBANK_SOURCES = {
     "agdt", "ud_perseus", "ud_proiel", "ud_ptnk", "gorman", "pedalion",
     "harrington",
@@ -63,6 +70,11 @@ def test_readme_configuration_counts_match_parquet_rows() -> None:
                 flags=re.MULTILINE,
             )
         }
+        # One README documents both sentence tracks, so match on this base.
+        table_rows = {
+            config: counts for config, counts in table_rows.items()
+            if config.rsplit("_", 1)[0] == base
+        }
         expected_configs = {f"{base}_{suffix}" for suffix in suffixes}
         assert set(table_rows) == expected_configs
         for config in sorted(expected_configs):
@@ -77,7 +89,7 @@ def test_readme_configuration_counts_match_parquet_rows() -> None:
 
 
 def test_readme_author_unit_counts_and_shares_match_atomic_parquets() -> None:
-    for root, base, _suffixes in PUBLICATIONS:
+    for root, base, _suffixes in README_AUTHOR_TABLES:
         readme = (root / "README.md").read_text(encoding="utf-8")
         documented = {
             match.group("author"): {

tests/test_verse_character_coverage.py

@@ -29,6 +29,7 @@ def normalized_character_count(root: Path, config: str) -> int:
 def test_each_publication_has_equal_character_counts_across_task_sizes() -> None:
     publications = (
         (REPO_ROOT, "sentence", (1, 10, 50, 100)),
+        (REPO_ROOT, "source_held_out", (1, 10, 50, 100)),
         (REPO_ROOT.parent / "sphragis-metre", "verse", (1, 10, 50, 100)),
     )
     for root, genre, suffixes in publications: