Add Sphregis 0.1 beta dataset

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]

CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.1.0-beta — 2026-08-17
+
+- Added fixed `prose`, `verse_sentence`, and `verse_metre` configurations.
+- Added sentence-level CoNLL-U conversion for licensed native XML treebanks.
+- Added exact normalized prose deduplication with merged provenance.
+- Added exact full-line alignment between human syntax and updated Hypotactic
+  metrical HTML.
+- Added deterministic 80/10/10 train/validation/test splits stratified by
+  author and work; paired verse rows always share their parent's split.
+- Added per-row source revisions, licenses and annotation provenance.

LICENSES.md

@@ -0,0 +1,29 @@
+# Upstream licenses
+
+Sphregis is an aggregation of independently licensed annotations. The license
+for every contributing record is stored in `source_records`, and the distinct
+licenses governing a row are repeated in `licenses`.
+
+| Source | Annotation/data license used by this beta |
+|---|---|
+| Ancient Greek Dependency Treebank 2.1 | CC BY-SA 3.0 US |
+| UD Ancient Greek–Perseus | CC BY-NC-SA 2.5 |
+| UD Ancient Greek–PROIEL | CC BY-NC-SA 3.0 |
+| UD Ancient Greek–PTNK | CC BY-SA 4.0 |
+| Gorman Greek Dependency Trees | CC BY-NC-SA 4.0, conservatively interpreted |
+| Pedalion Trees | CC BY-SA 4.0 |
+| Harrington Trees | CC BY-SA 4.0 |
+| Hypotactic metrical annotation | CC BY 4.0 |
+
+The Gorman repository is internally inconsistent: its README says
+CC BY-NC-SA 4.0, while its bundled license text says CC BY-SA 4.0. Sphregis
+uses the more restrictive interpretation pending clarification.
+
+Aphthonius' *Progymnasmata* is not redistributed because its upstream
+repository specifies no license. Pedalion's mixed-author example collections
+and papyri are also omitted because they cannot be assigned reliable author
+labels at sentence level.
+
+This repository's build scripts and original documentation are released under
+CC BY 4.0. That does not replace or relax any upstream license, including
+NonCommercial and ShareAlike terms.

README.md

@@ -0,0 +1,178 @@
+---
+pretty_name: Sphregis
+language:
+- grc
+license: other
+task_categories:
+- text-classification
+tags:
+- authorship-attribution
+- ancient-greek
+- conllu
+- dependency-parsing
+- metre
+- scansion
+configs:
+- config_name: prose
+  data_files:
+  - split: train
+    path: data/prose/train-*
+  - split: validation
+    path: data/prose/validation-*
+  - split: test
+    path: data/prose/test-*
+- config_name: verse_sentence
+  data_files:
+  - split: train
+    path: data/verse_sentence/train-*
+  - split: validation
+    path: data/verse_sentence/validation-*
+  - split: test
+    path: data/verse_sentence/test-*
+- config_name: verse_metre
+  data_files:
+  - split: train
+    path: data/verse_metre/train-*
+  - split: validation
+    path: data/verse_metre/validation-*
+  - split: test
+    path: data/verse_metre/test-*
+---
+
+# Sphregis
+
+Sphregis is a provenance-preserving benchmark for Ancient Greek authorship
+attribution. Beta 0.1 combines licensed, human-annotated dependency treebanks
+and the metrically annotated [Hypotactic](https://github.com/Urdatorn/hypotactic)
+corpus. It supplies fixed train, validation and test splits.
+
+This is a beta release intended to make the data inspectable before final
+author/work selection and benchmark protocol design.
+
+## Configurations
+
+| Configuration | Unit | Train | Validation | Test | Total |
+|---|---|---:|---:|---:|---:|
+| `prose` | One deduplicated treebank sentence | 45,573 | 5,696 | 5,696 | 56,965 |
+| `verse_sentence` | One treebank sentence containing at least one complete scanned line | 11,995 | 1,500 | 1,500 | 14,995 |
+| `verse_metre` | One complete scanned line contained in a single treebank sentence | 22,264 | 2,841 | 2,752 | 27,857 |
+
+The verse configurations are paired: every `verse_metre` row contains a
+`parent_sentence_id`, and parent and child always occur in the same split.
+
+```python
+from datasets import load_dataset
+
+prose = load_dataset("Urdatorn/sphregis", "prose")
+verse_syntax = load_dataset("Urdatorn/sphregis", "verse_sentence")
+verse_metre = load_dataset("Urdatorn/sphregis", "verse_metre")
+```
+
+## Inclusion rule for verse
+
+A verse line is included only if:
+
+1. the current Hypotactic HTML provides its complete text and metrical scan;
+2. its complete normalized text occurs within one human-annotated treebank
+   sentence; and
+3. that sentence has been converted to CoNLL-U without discarding the native
+   dependency tree.
+
+Alignment first consults CTS and line references, then verifies full textual
+containment. When editions disagree about line numbering, an exact containment
+search over the work is used. Fuzzy matches and lines divided between two
+treebank sentences are excluded.
+
+The resulting verse material covers the *Iliad*, *Odyssey*, *Hymn to Demeter*,
+the three Hesiodic works, Aeschylus' *Persians*, *Prometheus Bound* and *Seven
+Against Thebes*, the *Batrachomyomachia*, Semonides, and Theocritus fragments.
+
+## Splits
+
+Splits are deterministic and stratified within each author/work group:
+approximately 80% train, 10% validation and 10% test. Groups with 3–9 rows
+receive one validation and one test row; groups with fewer than three rows stay
+in training. This beta deliberately provides sentence-level splits as
+requested. A stricter work-held-out evaluation can be added as a later
+benchmark track.
+
+## Principal columns
+
+All configurations contain:
+
+- `id`, `author`, `work`, `work_id`, `genre`, `text`;
+- `conllu`, `cts_urn`, `passage`, `treebank_source`;
+- `source_records`: JSON containing every contributing upstream record,
+  revision, URL, license, annotation provenance and syntax scheme;
+- `licenses`, `dedup_key`, and `split`.
+
+`verse_sentence` additionally contains a JSON list of complete
+`metrical_lines`. `verse_metre` contains `parent_sentence_id`, `book`,
+`line_number`, raw Hypotactic `metre`, `scansion`, syllable-level annotations,
+and the originating Hypotactic filename.
+
+`genre` has exactly three values in this release: `prose`, `verse_sentence`,
+and `verse_metre`.
+
+## Dependency representation
+
+Existing UD data is retained verbatim. Native AGDT/Arethusa trees are
+serialized as CoNLL-U while preserving heads and native relations. A
+best-effort UPOS and feature conversion is included, but native relations are
+not misrepresented as manually annotated UD relations: they appear as valid
+`dep:<native>` subtypes. `NativeRel` and `NativeHead` in MISC preserve the
+source values. Repairs required after removing artificial ellipsis nodes—or to
+break an upstream beta self-loop/cycle—are explicitly marked `HeadRepair=Yes`.
+
+## Deduplication
+
+Prose input comprised 72,336 sentences. Exact normalization-based
+deduplication removed 14,203 repeated rows. A further 1,168 rows in 289 exact
+text groups were omitted because their author labels conflict, leaving 56,965
+rows. Normalization lowercases, maps final sigma, removes diacritics and
+retains letters only. The chosen parse follows a deterministic source
+priority, while all exact-source provenance is merged into `source_records`.
+
+This is aggressive exact deduplication, not passage-level fuzzy
+deduplication. Segmentation or edition differences can therefore leave near
+duplicates for future review.
+
+## Sources and licensing
+
+The corpus draws on [AGDT 2.1](https://github.com/PerseusDL/treebank_data),
+[UD Perseus](https://github.com/UniversalDependencies/UD_Ancient_Greek-Perseus),
+[UD PROIEL](https://github.com/UniversalDependencies/UD_Ancient_Greek-PROIEL),
+[UD PTNK](https://github.com/UniversalDependencies/UD_Ancient_Greek-PTNK),
+[Gorman's Greek Dependency Trees](https://github.com/vgorman1/Greek-Dependency-Trees),
+[Pedalion](https://github.com/perseids-publications/pedalion-trees),
+[Harrington Trees](https://github.com/perseids-publications/harrington-trees),
+and [Hypotactic](https://github.com/Urdatorn/hypotactic).
+
+This is a mixed-license dataset, including NonCommercial and ShareAlike data.
+Consult [LICENSES.md](LICENSES.md) and the licenses recorded on every row.
+Source commits for this release are frozen in
+[`metadata/source_revisions.json`](metadata/source_revisions.json).
+
+Aphthonius is not redistributed because its repository does not specify a
+license. Mixed-author Pedalion example collections and papyri are omitted
+because they cannot be given reliable author labels at sentence level. A Latin
+Cicero file incorrectly stored under Harrington's `grctb` path is also omitted.
+
+## Authorship caveat
+
+`author` records conventional or received attribution, not a universal claim
+about historical authorship. Labels such as Homer, Pseudo-Homer, anonymous
+Septuagint material and traditionally attributed New Testament books require
+appropriate philological interpretation.
+
+## Reproduction
+
+```bash
+python -m pip install -r requirements-build.txt
+python scripts/build_dataset.py --sources /path/to/frozen/checkouts
+python scripts/validate_dataset.py --data data
+```
+
+See [SOURCES.md](SOURCES.md) for conversion and alignment details and
+[`metadata/build_report.json`](metadata/build_report.json) for machine-readable
+counts, exclusions, alignment yields and validation results.

SOURCES.md

@@ -0,0 +1,42 @@
+# Sources and provenance
+
+Exact source revisions used for the published files are recorded in
+`metadata/source_revisions.json`. Each row also contains a JSON-encoded
+`source_records` field with source project, file, sentence/line identifier,
+revision, URL, annotation provenance, syntax scheme and license.
+
+The beta integrates:
+
+- Ancient Greek Dependency Treebank 2.1;
+- UD Ancient Greek–Perseus r2.17;
+- UD Ancient Greek–PROIEL r2.17;
+- UD Ancient Greek–PTNK r2.17;
+- Gorman's Greek Dependency Trees;
+- Pedalion Trees;
+- Harrington Trees;
+- the current Hypotactic Greek metrical HTML corpus.
+
+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`.
+
+Exact prose duplicates are identified by lowercasing, converting final sigma,
+removing diacritics, and retaining letters only. One syntactic representation
+is retained according to the documented source priority, while provenance for
+all exact duplicates is merged into `source_records`.
+
+If the same normalized sentence occurs under more than one author label, all
+instances are omitted rather than assigning the text arbitrarily. Counts and
+examples of these conflicts are recorded in `metadata/build_report.json`.
+
+Verse alignment is intentionally conservative. A scanned line is admitted
+only when its complete normalized text is contained in a single human-
+annotated treebank sentence. CTS/line references narrow candidate lines when
+they agree; exact full-line containment is still required. If two editions use
+different line numbering, the aligner falls back to exact containment over the
+work. There are no fuzzy alignments in beta 0.1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

metadata/build_report.json

@@ -0,0 +1,465 @@
+{
+  "alignment": {
+    "pedalion:batracho.xml": {
+      "matched_lines": 102,
+      "matched_sentences": 67,
+      "sentences": 166
+    },
+    "pedalion:semonides.xml": {
+      "matched_lines": 69,
+      "matched_sentences": 39,
+      "sentences": 58
+    },
+    "pedalion:theoc.xml": {
+      "matched_lines": 17,
+      "matched_sentences": 11,
+      "sentences": 18
+    },
+    "tlg0012.tlg001": {
+      "matched_lines": 13547,
+      "matched_sentences": 7138,
+      "sentences": 8415
+    },
+    "tlg0012.tlg002": {
+      "matched_lines": 10454,
+      "matched_sentences": 5657,
+      "sentences": 6721
+    },
+    "tlg0013.tlg002": {
+      "matched_lines": 418,
+      "matched_sentences": 192,
+      "sentences": 255
+    },
+    "tlg0020.tlg001": {
+      "matched_lines": 688,
+      "matched_sentences": 336,
+      "sentences": 437
+    },
+    "tlg0020.tlg002": {
+      "matched_lines": 607,
+      "matched_sentences": 357,
+      "sentences": 490
+    },
+    "tlg0020.tlg003": {
+      "matched_lines": 261,
+      "matched_sentences": 163,
+      "sentences": 255
+    },
+    "tlg0085.tlg002": {
+      "matched_lines": 602,
+      "matched_sentences": 330,
+      "sentences": 480
+    },
+    "tlg0085.tlg003": {
+      "matched_lines": 575,
+      "matched_sentences": 373,
+      "sentences": 590
+    },
+    "tlg0085.tlg004": {
+      "matched_lines": 572,
+      "matched_sentences": 332,
+      "sentences": 515
+    }
+  },
+  "data_files": {
+    "prose": {
+      "test": 5696,
+      "train": 45573,
+      "validation": 5696
+    },
+    "verse_metre": {
+      "test": 2752,
+      "train": 22264,
+      "validation": 2841
+    },
+    "verse_sentence": {
+      "test": 1500,
+      "train": 11995,
+      "validation": 1500
+    }
+  },
+  "deduplication": {
+    "conflict_examples": [
+      {
+        "authors": [
+          "Dionysius of Halicarnassus",
+          "Plutarch"
+        ],
+        "dedup_key": "ef2f6aaa4ea144c2cb1cbd159c1ce28db11a070c2cf4974eb5e0b59af8b4e5a4",
+        "normalized_length": 11,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Plutarch",
+          "Xenophon"
+        ],
+        "dedup_key": "74adb07c15882d295c2185206fd6063f68d901044dbff7f8b16a9d4196d0334e",
+        "normalized_length": 11,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Plutarch",
+          "Xenophon"
+        ],
+        "dedup_key": "d66d4852420ec9d50e806d5e095ced0ee1a701eb0955dd53f3ed249043e703ea",
+        "normalized_length": 18,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Xenophon"
+        ],
+        "dedup_key": "a58f7ce0af7bad72f1a6a3a5856e0fb89b8274eb99dc6bdda01a2ea46a47af1f",
+        "normalized_length": 84,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Xenophon"
+        ],
+        "dedup_key": "cd3c1ca5491d1e2074d8ca47ba86ac8352c39979b5d8d422ba59ff2bb725ff41",
+        "normalized_length": 36,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Xenophon"
+        ],
+        "dedup_key": "ab825b299c33a1a097021efd1a4b42767a434f1c89739d38e949b4091155ef55",
+        "normalized_length": 42,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Chariton"
+        ],
+        "dedup_key": "a4df924ee56cfcdcfea2ff670f57d46e8273afe5e16e3d17b44056767f40b4c7",
+        "normalized_length": 14,
+        "sources": [
+          "agdt",
+          "gorman",
+          "pedalion",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Plato"
+        ],
+        "dedup_key": "c9dd7f4a9c0c3aff029800ba0a1453bff595b729b286af1430345ffb09d98f51",
+        "normalized_length": 5,
+        "sources": [
+          "agdt",
+          "gorman",
+          "pedalion",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Plato"
+        ],
+        "dedup_key": "34f9df46bc85c3c50e5b6ad7a98d6174a028b5ee7acc04cb315951ddd67aa54a",
+        "normalized_length": 4,
+        "sources": [
+          "agdt",
+          "gorman",
+          "pedalion",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Athenaeus",
+          "Lysias"
+        ],
+        "dedup_key": "e4af215095814693762f9993a1620a265e24cc9edeff07d680c846d8562995de",
+        "normalized_length": 27,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Diodorus Siculus",
+          "Polybius"
+        ],
+        "dedup_key": "62a8d7ea990027b7b26cdb4a9990d79688b648c505ad1c307df1a4abc07421de",
+        "normalized_length": 18,
+        "sources": [
+          "agdt",
+          "gorman",
+          "ud_perseus"
+        ]
+      },
+      {
+        "authors": [
+          "Herodotus",
+          "Xenophon"
+        ],
+        "dedup_key": "9643413d02440657dc9431f34eec218cb047c4c2b31413c9f589967d87f21080",
+        "normalized_length": 7,
+        "sources": [
+          "gorman",
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)"
+        ],
+        "dedup_key": "72c2af7ece94a0563e4ad76366320deb13bb6335b128c299010b90156484d410",
+        "normalized_length": 37,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)"
+        ],
+        "dedup_key": "32cbae49e112c7d613d27b316a48c2a4e353da24406d90e94c641752f7c6bcfd",
+        "normalized_length": 13,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "John (traditional)",
+          "Luke (traditional)",
+          "Mark (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "29b7d494fa478f295de9297ae2d07642c49f1c765475aeaa4fc1e48c21fb9e6d",
+        "normalized_length": 12,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)"
+        ],
+        "dedup_key": "df0165a9e00acc71bff5fd94f8ab08b71b5edf223e52a82e5fad0f8cab8b09f1",
+        "normalized_length": 18,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "22f08ab66dc8fa8a5a787d971aee364b127f6fa1b067256857eaf6f34fb585d4",
+        "normalized_length": 12,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "8035454856be0ae19075064cf04c7a883fe286a0186d375e629ceb0eb5c0bb43",
+        "normalized_length": 26,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Anonymous (Septuagint)",
+          "John of Patmos",
+          "Luke (traditional)",
+          "Mark (traditional)"
+        ],
+        "dedup_key": "0f4ac3810e8c5f0294e25297c940d50ce54ab8450a937abccdf055ac50b2cee6",
+        "normalized_length": 7,
+        "sources": [
+          "pedalion",
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Mark (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "0c88d0c7bd0dad89a1fd1a6647d11adab482878948817a764e3baa917741265b",
+        "normalized_length": 17,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "John (traditional)",
+          "Mark (traditional)"
+        ],
+        "dedup_key": "be586edd2ca7760629d437da1dbe05606f931591a714e437de6eae005cbd5ca6",
+        "normalized_length": 6,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "739abaad18b93483543e3dd6336e5f5c7b3cf8644571e52ceca69bb99189a6ed",
+        "normalized_length": 31,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "02d77ceefff126956c97f7d55932b3978a12d3b7e25e691df81c68b08bbe6d0d",
+        "normalized_length": 4,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)",
+          "Matthew (traditional)"
+        ],
+        "dedup_key": "60d9d5fe3ed2f9f00d6ab0b496198447d8910e58772d97026ce621e25199c237",
+        "normalized_length": 11,
+        "sources": [
+          "ud_proiel"
+        ]
+      },
+      {
+        "authors": [
+          "Luke (traditional)",
+          "Mark (traditional)"
+        ],
+        "dedup_key": "384457f99bd6c8b79b397c4401a1937d38a742611621288886c74323a9b01924",
+        "normalized_length": 7,
+        "sources": [
+          "ud_proiel"
+        ]
+      }
+    ],
+    "conflicting_author_groups_removed": 289,
+    "conflicting_author_rows_removed": 1168,
+    "duplicate_groups": 8578,
+    "input_rows": 72336,
+    "output_rows": 56965,
+    "removed_exact_duplicates": 14203
+  },
+  "excluded": {
+    "aphthonius": "No redistribution license is specified upstream.",
+    "harrington_grctb_805": "File declares xml:lang=lat and contains Cicero despite its grctb path.",
+    "pedalion_mixed": [
+      "chilia-sentences.xml",
+      "example-sentences.xml",
+      "external_examplesentences.xml",
+      "papyri.xml"
+    ]
+  },
+  "validation": {
+    "checks": {
+      "prose_exact_text_unique": true,
+      "unique_ids": true,
+      "verse_parent_split_consistency": true
+    },
+    "prose": {
+      "authors": 51,
+      "rows": 56965,
+      "sources": {
+        "agdt": 1114,
+        "gorman": 24795,
+        "harrington": 1012,
+        "pedalion": 8783,
+        "ud_perseus": 4464,
+        "ud_proiel": 15221,
+        "ud_ptnk": 1576
+      },
+      "splits": {
+        "test": 5696,
+        "train": 45573,
+        "validation": 5696
+      },
+      "works": 110
+    },
+    "verse_metre": {
+      "authors": 6,
+      "rows": 27857,
+      "sources": {
+        "agdt": 27671,
+        "pedalion": 186
+      },
+      "splits": {
+        "test": 2752,
+        "train": 22264,
+        "validation": 2841
+      },
+      "works": 12
+    },
+    "verse_sentence": {
+      "authors": 6,
+      "rows": 14995,
+      "sources": {
+        "agdt": 14878,
+        "pedalion": 117
+      },
+      "splits": {
+        "test": 1500,
+        "train": 11995,
+        "validation": 1500
+      },
+      "works": 12
+    }
+  }
+}

metadata/source_revisions.json

@@ -0,0 +1,66 @@
+{
+  "agdt": {
+    "directory": "treebank_data",
+    "url": "https://github.com/PerseusDL/treebank_data",
+    "license": "CC-BY-SA-3.0-US",
+    "annotation": "manual syntax; Morpheus-assisted morphology; normalized in AGDT 2.1",
+    "scheme": "AGDT/ALDT",
+    "revision": "bf4334f0af5e13d16b04c1cccd6237e683ac6f5f"
+  },
+  "ud_perseus": {
+    "directory": "perseus",
+    "url": "https://github.com/UniversalDependencies/UD_Ancient_Greek-Perseus",
+    "license": "CC-BY-NC-SA-2.5",
+    "annotation": "UD conversion of manually annotated AGDT syntax",
+    "scheme": "Universal Dependencies 2",
+    "revision": "37837c7a3c592c9563f8c51cc63344b87247f8a5"
+  },
+  "ud_proiel": {
+    "directory": "proiel",
+    "url": "https://github.com/UniversalDependencies/UD_Ancient_Greek-PROIEL",
+    "license": "CC-BY-NC-SA-3.0",
+    "annotation": "UD conversion of manually annotated PROIEL data",
+    "scheme": "Universal Dependencies 2",
+    "revision": "1e801c6eeda66797e749245c78a045e7d136c99c"
+  },
+  "ud_ptnk": {
+    "directory": "ptnk",
+    "url": "https://github.com/UniversalDependencies/UD_Ancient_Greek-PTNK",
+    "license": "CC-BY-SA-4.0",
+    "annotation": "cross-lingual projection with automatic and manual correction",
+    "scheme": "Universal Dependencies 2",
+    "revision": "df0b550c9c6b52a568a0184bfcf190279ffe501a"
+  },
+  "gorman": {
+    "directory": "gorman",
+    "url": "https://github.com/vgorman1/Greek-Dependency-Trees",
+    "license": "CC-BY-NC-SA-4.0 (conservative; upstream files conflict)",
+    "annotation": "hand annotated, or hand corrected after preparsing",
+    "scheme": "AGDT/Arethusa",
+    "revision": "d823e96d253277bc1872b83ff5ac8c393a0f830a"
+  },
+  "pedalion": {
+    "directory": "pedalion",
+    "url": "https://github.com/perseids-publications/pedalion-trees",
+    "license": "CC-BY-SA-4.0",
+    "annotation": "human corrected after automatic preparsing; beta annotations",
+    "scheme": "AGDT/Arethusa",
+    "revision": "112c106b86b865ddde4be7e5f3e409d9c42689f9"
+  },
+  "harrington": {
+    "directory": "harrington",
+    "url": "https://github.com/perseids-publications/harrington-trees",
+    "license": "CC-BY-SA-4.0",
+    "annotation": "student annotation edited by J. Matthew Harrington",
+    "scheme": "Harrington/Arethusa",
+    "revision": "bef859dc41fd5e62104a6752d979770035468fd2"
+  },
+  "hypotactic": {
+    "directory": "hypotactic",
+    "url": "https://github.com/Urdatorn/hypotactic",
+    "license": "CC-BY-4.0",
+    "annotation": "human metrical annotation by David Chamberlain; NLP repackaging by Urdatorn",
+    "scheme": "Hypotactic scansion HTML",
+    "revision": "9f478ac82db30d6c16f7dfe7fa49056147ed1785"
+  }
+}

requirements-build.txt

@@ -0,0 +1 @@
+pyarrow>=21,<22

scripts/build_dataset.py

@@ -0,0 +1,1016 @@
+#!/usr/bin/env python3
+"""Build the Sphregis beta dataset from frozen Ancient Greek treebanks.
+
+The build is deliberately source-driven: source repositories are not vendored in
+the dataset repository.  Pass their checkout root with ``--sources``.  Every
+published row records the exact upstream commit used by the build.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import html
+import json
+import re
+import subprocess
+import unicodedata
+import xml.etree.ElementTree as ET
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Iterable
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+SOURCE_INFO = {
+    "agdt": {
+        "directory": "treebank_data",
+        "url": "https://github.com/PerseusDL/treebank_data",
+        "license": "CC-BY-SA-3.0-US",
+        "annotation": "manual syntax; Morpheus-assisted morphology; normalized in AGDT 2.1",
+        "scheme": "AGDT/ALDT",
+    },
+    "ud_perseus": {
+        "directory": "perseus",
+        "url": "https://github.com/UniversalDependencies/UD_Ancient_Greek-Perseus",
+        "license": "CC-BY-NC-SA-2.5",
+        "annotation": "UD conversion of manually annotated AGDT syntax",
+        "scheme": "Universal Dependencies 2",
+    },
+    "ud_proiel": {
+        "directory": "proiel",
+        "url": "https://github.com/UniversalDependencies/UD_Ancient_Greek-PROIEL",
+        "license": "CC-BY-NC-SA-3.0",
+        "annotation": "UD conversion of manually annotated PROIEL data",
+        "scheme": "Universal Dependencies 2",
+    },
+    "ud_ptnk": {
+        "directory": "ptnk",
+        "url": "https://github.com/UniversalDependencies/UD_Ancient_Greek-PTNK",
+        "license": "CC-BY-SA-4.0",
+        "annotation": "cross-lingual projection with automatic and manual correction",
+        "scheme": "Universal Dependencies 2",
+    },
+    "gorman": {
+        "directory": "gorman",
+        "url": "https://github.com/vgorman1/Greek-Dependency-Trees",
+        # The README says NC; the bundled license text omits NC. Use the
+        # conservative interpretation until the maintainer resolves it.
+        "license": "CC-BY-NC-SA-4.0 (conservative; upstream files conflict)",
+        "annotation": "hand annotated, or hand corrected after preparsing",
+        "scheme": "AGDT/Arethusa",
+    },
+    "pedalion": {
+        "directory": "pedalion",
+        "url": "https://github.com/perseids-publications/pedalion-trees",
+        "license": "CC-BY-SA-4.0",
+        "annotation": "human corrected after automatic preparsing; beta annotations",
+        "scheme": "AGDT/Arethusa",
+    },
+    "harrington": {
+        "directory": "harrington",
+        "url": "https://github.com/perseids-publications/harrington-trees",
+        "license": "CC-BY-SA-4.0",
+        "annotation": "student annotation edited by J. Matthew Harrington",
+        "scheme": "Harrington/Arethusa",
+    },
+    "hypotactic": {
+        "directory": "hypotactic",
+        "url": "https://github.com/Urdatorn/hypotactic",
+        "license": "CC-BY-4.0",
+        "annotation": "human metrical annotation by David Chamberlain; NLP repackaging by Urdatorn",
+        "scheme": "Hypotactic scansion HTML",
+    },
+}
+
+
+AGDT_WORKS = {
+    "tlg0003.tlg001": ("Thucydides", "Histories, Book 1", "prose"),
+    "tlg0007.tlg004": ("Plutarch", "Lycurgus", "prose"),
+    "tlg0007.tlg015": ("Plutarch", "Alcibiades", "prose"),
+    "tlg0008.tlg001": ("Athenaeus", "Deipnosophists, Books 12–13", "prose"),
+    "tlg0011.tlg001": ("Sophocles", "Trachiniae", "verse"),
+    "tlg0011.tlg002": ("Sophocles", "Antigone", "verse"),
+    "tlg0011.tlg003": ("Sophocles", "Ajax", "verse"),
+    "tlg0011.tlg004": ("Sophocles", "Oedipus Tyrannus", "verse"),
+    "tlg0011.tlg005": ("Sophocles", "Electra", "verse"),
+    "tlg0012.tlg001": ("Homer", "Iliad", "verse"),
+    "tlg0012.tlg002": ("Homer", "Odyssey", "verse"),
+    "tlg0013.tlg002": ("Pseudo-Homer", "Hymn to Demeter", "verse"),
+    "tlg0016.tlg001": ("Herodotus", "Histories, Book 1", "prose"),
+    "tlg0020.tlg001": ("Hesiod", "Theogony", "verse"),
+    "tlg0020.tlg002": ("Hesiod", "Works and Days", "verse"),
+    "tlg0020.tlg003": ("Hesiod", "Shield of Heracles", "verse"),
+    "tlg0059.tlg001": ("Plato", "Euthyphro", "prose"),
+    "tlg0060.tlg001": ("Diodorus Siculus", "Library, Book 11", "prose"),
+    "tlg0085.tlg001": ("Aeschylus", "Suppliants", "verse"),
+    "tlg0085.tlg002": ("Aeschylus", "Persians", "verse"),
+    "tlg0085.tlg003": ("Aeschylus", "Prometheus Bound", "verse"),
+    "tlg0085.tlg004": ("Aeschylus", "Seven Against Thebes", "verse"),
+    "tlg0085.tlg005": ("Aeschylus", "Agamemnon", "verse"),
+    "tlg0085.tlg006": ("Aeschylus", "Libation Bearers", "verse"),
+    "tlg0085.tlg007": ("Aeschylus", "Eumenides", "verse"),
+    "tlg0096.tlg002": ("Aesop", "Fables 1–50", "prose"),
+    "tlg0540.tlg001": ("Lysias", "On the Murder of Eratosthenes", "prose"),
+    "tlg0540.tlg014": ("Lysias", "Against Alcibiades 1", "prose"),
+    "tlg0540.tlg015": ("Lysias", "Against Alcibiades 2", "prose"),
+    "tlg0540.tlg023": ("Lysias", "Against Pancleon", "prose"),
+    "tlg0543.tlg001": ("Polybius", "Histories, Book 1", "prose"),
+    "tlg0548.tlg001": ("Pseudo-Apollodorus", "Library 1.1.1–1.4.1", "prose"),
+}
+
+
+# Hypotactic file stems aligned to human treebanks.  Booked works expand below.
+VERSE_LINKS = {
+    "tlg0012.tlg001": {"files": [f"iliad{i}" for i in range(1, 25)]},
+    "tlg0012.tlg002": {"files": [f"odyssey{i}" for i in range(1, 25)]},
+    "tlg0013.tlg002": {"files": ["HHDemeter"]},
+    "tlg0020.tlg001": {"files": ["theogony"]},
+    "tlg0020.tlg002": {"files": ["worksanddays"]},
+    "tlg0020.tlg003": {"files": ["scutum"]},
+    "tlg0085.tlg002": {"files": ["persians"]},
+    "tlg0085.tlg003": {"files": ["prometheus"]},
+    "tlg0085.tlg004": {"files": ["seven"]},
+    "pedalion:batracho.xml": {"files": ["batmumach"]},
+    "pedalion:semonides.xml": {"files": ["semonides"]},
+    "pedalion:theoc.xml": {"files": ["theoc1", "theoc2", "theoc3", "theoc4"]},
+}
+
+
+PEDALION_VERSE = {
+    "achar.xml",
+    "thesmo.xml",
+    "euripides_medea.xml",
+    "ez.xml",
+    "batracho.xml",
+    "menander_dyskolos.xml",
+    "sappho.xml",
+    "semonides.xml",
+    "theoc.xml",
+    "mimn.xml",
+}
+
+PEDALION_EXCLUDE = {
+    "papyri.xml",
+    "example-sentences.xml",
+    "external_examplesentences.xml",
+    "chilia-sentences.xml",
+}
+
+
+GORMAN_AUTHOR_PATTERNS = [
+    (r"^Aeschines", "Aeschines"), (r"^Andocides", "Andocides"),
+    (r"^[Aa]ntiphon", "Antiphon"), (r"^Appian", "Appian"),
+    (r"^Aristotle", "Aristotle"), (r"^[Dd]em", "Demosthenes"),
+    (r"^Isaeus", "Isaeus"), (r"^Isocrates", "Isocrates"),
+    (r"^[Ll]ysias", "Lysias"), (r"^[Pp]lato", "Plato"),
+    (r"^[Pp]lut", "Plutarch"), (r"^[Pp]olybius", "Polybius"),
+    (r"^[Xx]en", "Xenophon"), (r"^[Aa]then", "Athenaeus"),
+    (r"^[Dd]iod", "Diodorus Siculus"), (r"^[Dd]ion hal", "Dionysius of Halicarnassus"),
+    (r"^[Hh]dt", "Herodotus"), (r"^[Jj]osephus", "Josephus"),
+    (r"^[Tt]huc", "Thucydides"), (r"^ps xen", "Pseudo-Xenophon"),
+]
+
+
+NT_BOOKS = {
+    "MATT": ("Matthew (traditional)", "Gospel of Matthew"),
+    "MARK": ("Mark (traditional)", "Gospel of Mark"),
+    "LUKE": ("Luke (traditional)", "Gospel of Luke"),
+    "ACTS": ("Luke (traditional)", "Acts"),
+    "JOHN": ("John (traditional)", "Gospel of John"),
+    "ROM": ("Paul (traditional)", "Romans"),
+    "GAL": ("Paul", "Galatians"), "EPH": ("Paul (traditional)", "Ephesians"),
+    "PHIL": ("Paul", "Philippians"), "COL": ("Paul (traditional)", "Colossians"),
+    "TIT": ("Paul (traditional)", "Titus"), "PHILEM": ("Paul", "Philemon"),
+    "HEB": ("Anonymous", "Hebrews"), "JAS": ("James (traditional)", "James"),
+    "JUDE": ("Jude (traditional)", "Jude"), "REV": ("John of Patmos", "Revelation"),
+}
+
+
+POS_MAP = {
+    "n": "NOUN", "v": "VERB", "a": "ADJ", "d": "ADV", "c": "SCONJ",
+    "r": "ADP", "p": "PRON", "l": "DET", "g": "PART", "b": "CCONJ",
+    "m": "NUM", "i": "INTJ", "u": "PUNCT", "e": "X", "x": "X",
+    "-": "X", "t": "VERB", "q": "ADV",
+}
+
+FEATURE_MAPS = [
+    ("Person", {"1": "1", "2": "2", "3": "3"}),
+    ("Number", {"s": "Sing", "p": "Plur", "d": "Dual"}),
+    ("Tense", {"p": "Pres", "i": "Past", "r": "Past", "l": "Past", "t": "Past", "f": "Fut", "a": "Past"}),
+    ("Mood", {"i": "Ind", "s": "Sub", "o": "Opt", "m": "Imp", "n": "Inf", "p": "Part", "g": "Ger"}),
+    ("Voice", {"a": "Act", "m": "Mid", "p": "Pass", "e": "Mid"}),
+    ("Gender", {"m": "Masc", "f": "Fem", "n": "Neut", "c": "Com"}),
+    ("Case", {"n": "Nom", "g": "Gen", "d": "Dat", "a": "Acc", "v": "Voc", "l": "Loc"}),
+    ("Degree", {"c": "Cmp", "s": "Sup", "p": "Pos"}),
+]
+
+
+@dataclass
+class Sentence:
+    source: str
+    source_file: str
+    source_sentence_id: str
+    author: str
+    work: str
+    work_id: str
+    text: str
+    conllu: str
+    cts_urn: str = ""
+    passage: str = ""
+    genre: str = "prose"
+    native_cites: list[str] = field(default_factory=list)
+    priority: int = 50
+    source_records: list[dict] = field(default_factory=list)
+
+    @property
+    def normalized(self) -> str:
+        return normalize(self.text)
+
+
+def normalize(text: str) -> str:
+    text = text.lower().replace("ς", "σ")
+    text = "".join(
+        char for char in unicodedata.normalize("NFD", text)
+        if unicodedata.category(char) != "Mn"
+    )
+    return "".join(char for char in text if char.isalpha())
+
+
+def slug(text: str) -> str:
+    value = unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode().lower()
+    value = re.sub(r"[^a-z0-9]+", "-", value).strip("-")
+    return value or "unknown"
+
+
+def canonical_author(author: str) -> str:
+    return {
+        "Aesopus": "Aesop",
+        "Anon.": "Anonymous (Septuagint)",
+        "Lucianus": "Lucian",
+        "Pseudo-Lucianus": "Pseudo-Lucian",
+        "(Pseudo-Homer)": "Pseudo-Homer",
+        "Ezechiël": "Ezechiel",
+    }.get(author.strip(), author.strip() or "Unknown")
+
+
+def stable_id(*parts: str, length: int = 20) -> str:
+    return hashlib.sha256("\x1f".join(parts).encode()).hexdigest()[:length]
+
+
+def git_revision(path: Path) -> str:
+    return subprocess.check_output(["git", "-C", str(path), "rev-parse", "HEAD"], text=True).strip()
+
+
+def source_record(source: str, revisions: dict[str, str], source_file: str, sentence_id: str) -> dict:
+    info = SOURCE_INFO[source]
+    return {
+        "source": source,
+        "source_file": source_file,
+        "source_sentence_id": sentence_id,
+        "url": info["url"],
+        "revision": revisions[source],
+        "license": info["license"],
+        "annotation_provenance": info["annotation"],
+        "syntax_scheme": info["scheme"],
+    }
+
+
+def infer_cts(value: str) -> str:
+    match = re.search(r"urn:cts:[^\s]+", value or "")
+    if not match:
+        return ""
+    return match.group(0).removesuffix(".tb")
+
+
+def cts_key(value: str) -> str:
+    match = re.search(r"(tlg\d+\.tlg\d+)", value)
+    return match.group(1) if match else ""
+
+
+def morph_features(postag: str) -> str:
+    tag = (postag or "---------").ljust(9, "-")[:9]
+    values = []
+    for index, (name, mapping) in enumerate(FEATURE_MAPS, 1):
+        if tag[index] in mapping:
+            values.append(f"{name}={mapping[tag[index]]}")
+    return "|".join(sorted(values)) or "_"
+
+
+def misc_field(values: dict[str, str]) -> str:
+    fields = []
+    for key, value in values.items():
+        if value:
+            clean = str(value).replace("|", ",").replace(" ", "_")
+            fields.append(f"{key}={clean}")
+    return "|".join(fields) or "_"
+
+
+def smart_text(forms: Iterable[str]) -> str:
+    result = ""
+    no_space_before = set(",.;··:!?;)]}»”")
+    no_space_after = set("([{«“")
+    for form in forms:
+        if not result:
+            result = form
+        elif form and form[0] in no_space_before:
+            result += form
+        elif result[-1] in no_space_after:
+            result += form
+        else:
+            result += " " + form
+    return result
+
+
+def xml_sentence_to_conllu(sentence: ET.Element, metadata: dict[str, str]) -> tuple[str, str, list[str]]:
+    words = list(sentence.findall("word"))
+    real = [
+        word for word in words
+        if not word.get("artificial")
+        and (word.get("form") or "").strip() not in {"", "[0]", "_"}
+    ]
+    id_map = {word.get("id", ""): index for index, word in enumerate(real, 1)}
+    by_old_id = {word.get("id", ""): word for word in words}
+
+    def resolved_head(word: ET.Element) -> int:
+        head = word.get("head", "0")
+        seen = set()
+        while head not in id_map and head not in {"", "0", None} and head not in seen:
+            seen.add(head)
+            parent = by_old_id.get(head)
+            head = parent.get("head", "0") if parent is not None else "0"
+        return id_map.get(head, 0)
+
+    forms = [word.get("form", "_") for word in real]
+    text = smart_text(forms)
+    lines = [
+        f"# sent_id = {metadata['sent_id']}",
+        f"# text = {text}",
+        f"# source = {metadata['source']}",
+    ]
+    if metadata.get("cts"):
+        lines.append(f"# cts = {metadata['cts']}")
+    if metadata.get("passage"):
+        lines.append(f"# passage = {metadata['passage']}")
+
+    initial_heads = [resolved_head(word) for word in real]
+    root_candidates = [
+        index for index, (word, head) in enumerate(zip(real, initial_heads), 1)
+        if head == 0 and not word.get("postag", "").startswith("u")
+    ]
+    primary_root = root_candidates[0] if root_candidates else 1
+    final_heads = list(initial_heads)
+    for index, head in enumerate(final_heads, 1):
+        if index == primary_root:
+            final_heads[index - 1] = 0
+        elif head in {0, index}:
+            final_heads[index - 1] = primary_root
+    # A few beta trees contain cycles. Break each cycle at one node while
+    # retaining all other original heads; record provenance still points back
+    # to the source tree for audit.
+    for token_id in range(1, len(final_heads) + 1):
+        trail = []
+        cursor = token_id
+        while cursor:
+            if cursor in trail:
+                cycle = trail[trail.index(cursor):]
+                break_id = min(cycle)
+                final_heads[break_id - 1] = 0 if break_id == primary_root else primary_root
+                break
+            trail.append(cursor)
+            cursor = final_heads[cursor - 1]
+    cites = []
+    for new_id, word in enumerate(real, 1):
+        postag = word.get("postag", "---------")
+        head = final_heads[new_id - 1]
+        relation = word.get("relation", "dep")
+        if head == 0:
+            dep = "root"
+        elif postag.startswith("u"):
+            dep = "punct"
+        else:
+            dep = "dep:" + re.sub(r"[^a-z0-9]+", "", relation.lower())
+        if dep == "dep:":
+            dep = "dep"
+        cite = word.get("cite", "") or word.get("ref", "")
+        if cite:
+            cites.append(cite)
+        row = [
+            str(new_id), word.get("form", "_"), word.get("lemma", "_"),
+            POS_MAP.get(postag[:1].lower(), "X"), postag or "_", morph_features(postag),
+            str(head), dep, "_", misc_field({
+                "NativeRel": relation,
+                "NativeHead": word.get("head", ""),
+                "HeadRepair": "Yes" if head != initial_heads[new_id - 1] else "",
+                "Cite": cite,
+            }),
+        ]
+        lines.append("\t".join(row))
+    return text, "\n".join(lines) + "\n", cites
+
+
+def parse_agdt(root: Path, revisions: dict[str, str]) -> tuple[list[Sentence], list[Sentence]]:
+    prose, verse = [], []
+    text_root = root / "v2.1" / "Greek" / "texts"
+    for path in sorted(text_root.glob("*.xml")):
+        tree = ET.parse(path)
+        xml_root = tree.getroot()
+        key = cts_key(xml_root.get("cts", "") or path.name)
+        if key not in AGDT_WORKS:
+            continue
+        author, work, genre = AGDT_WORKS[key]
+        cts = infer_cts(xml_root.get("cts", "")) or f"urn:cts:greekLit:{key}"
+        for index, sent in enumerate(xml_root.iter("sentence"), 1):
+            sid = sent.get("id", str(index))
+            passage = sent.get("subdoc", "")
+            text, conllu, cites = xml_sentence_to_conllu(sent, {
+                "sent_id": f"agdt:{key}:{sid}", "source": path.name,
+                "cts": cts, "passage": passage,
+            })
+            if not normalize(text):
+                continue
+            row = Sentence(
+                source="agdt", source_file=path.name, source_sentence_id=sid,
+                author=author, work=work, work_id=key, text=text, conllu=conllu,
+                cts_urn=cts, passage=passage, genre=genre, native_cites=cites,
+                priority=10,
+            )
+            row.source_records = [source_record("agdt", revisions, path.name, sid)]
+            (verse if genre == "verse" else prose).append(row)
+    return prose, verse
+
+
+def conllu_blocks(path: Path) -> Iterable[dict]:
+    for raw in path.read_text(encoding="utf8").strip().split("\n\n"):
+        comments = {}
+        token_rows = []
+        for line in raw.splitlines():
+            if line.startswith("# ") and " = " in line:
+                key, value = line[2:].split(" = ", 1)
+                comments[key] = value
+            elif line and not line.startswith("#"):
+                fields = line.split("\t")
+                if len(fields) == 10:
+                    token_rows.append(fields)
+        if token_rows:
+            yield {"comments": comments, "tokens": token_rows, "conllu": raw + "\n"}
+
+
+def ud_identity(source: str, block: dict) -> tuple[str, str, str, str, str]:
+    comments, tokens = block["comments"], block["tokens"]
+    sent_id = comments.get("sent_id", "")
+    if source == "ud_perseus":
+        doc = sent_id.split("@", 1)[0]
+        key = cts_key(doc)
+        author, work, genre = AGDT_WORKS.get(key, ("Unknown", doc, "prose"))
+        return author, work, key or doc, genre, infer_cts(doc)
+    refs = [row[9] for row in tokens]
+    if source == "ud_ptnk":
+        joined = "|".join(refs)
+        book = "Ruth" if "Septuagint-Ruth" in joined else "Genesis"
+        return "Anonymous (Septuagint)", book, f"septuagint-{book.lower()}", "prose", ""
+    # PROIEL: Herodotus refs are numeric; New Testament refs carry a book prefix.
+    for misc in refs:
+        match = re.search(r"(?:^|\|)Ref=([A-Z]+)_", misc)
+        if match:
+            code = match.group(1)
+            author, work = NT_BOOKS.get(code, (f"Unknown ({code})", code))
+            return author, work, f"proiel-{code.lower()}", "prose", ""
+    return "Herodotus", "Histories (PROIEL selections)", "tlg0016.tlg001", "prose", "urn:cts:greekLit:tlg0016.tlg001"
+
+
+def parse_ud(source: str, root: Path, revisions: dict[str, str]) -> tuple[list[Sentence], list[Sentence]]:
+    prose, verse = [], []
+    for path in sorted(root.glob("*.conllu")):
+        for block in conllu_blocks(path):
+            comments = block["comments"]
+            author, work, work_id, genre, cts = ud_identity(source, block)
+            sid = comments.get("sent_id", stable_id(block["conllu"]))
+            text = comments.get("text") or smart_text(
+                row[1] for row in block["tokens"] if re.fullmatch(r"\d+", row[0])
+            )
+            if not normalize(text):
+                continue
+            cites = []
+            for token in block["tokens"]:
+                match = re.search(r"(?:^|\|)Ref=([^|]+)", token[9])
+                if match:
+                    cites.append(match.group(1))
+            row = Sentence(
+                source=source, source_file=path.name, source_sentence_id=sid,
+                author=author, work=work, work_id=work_id, text=text,
+                conllu=block["conllu"], cts_urn=cts,
+                passage=comments.get("source", ""), genre=genre, native_cites=cites,
+                priority=0,
+            )
+            row.source_records = [source_record(source, revisions, path.name, sid)]
+            (verse if genre == "verse" else prose).append(row)
+    return prose, verse
+
+
+def gorman_author(filename: str) -> str:
+    for pattern, author in GORMAN_AUTHOR_PATTERNS:
+        if re.search(pattern, filename, re.I if pattern.startswith("^") else 0):
+            return author
+    return "Unknown"
+
+
+def parse_native_collection(
+    source: str,
+    files: Iterable[Path],
+    revisions: dict[str, str],
+    metadata: dict[str, tuple[str, str]] | None = None,
+    verse_files: set[str] | None = None,
+) -> tuple[list[Sentence], list[Sentence]]:
+    prose, verse = [], []
+    metadata = metadata or {}
+    verse_files = verse_files or set()
+    for path in sorted(files):
+        try:
+            tree = ET.parse(path)
+        except ET.ParseError:
+            continue
+        xml_root = tree.getroot()
+        if xml_root.get("{http://www.w3.org/XML/1998/namespace}lang") == "lat":
+            continue
+        first = next(xml_root.iter("sentence"), None)
+        if first is None:
+            continue
+        if source == "gorman":
+            author, work = gorman_author(path.name), path.stem
+        else:
+            author, work = metadata.get(path.name, (first.get("Author", "") or "Unknown", path.stem))
+        author = canonical_author(author)
+        genre = "verse" if path.name in verse_files else "prose"
+        doc = first.get("document_id", "")
+        cts = infer_cts(doc)
+        work_id = cts_key(doc) or f"{source}:{slug(author)}:{slug(work)}"
+        for index, sent in enumerate(xml_root.iter("sentence"), 1):
+            sid = sent.get("id", str(index))
+            passage = sent.get("subdoc", "")
+            text, conllu, cites = xml_sentence_to_conllu(sent, {
+                "sent_id": f"{source}:{slug(path.stem)}:{sid}", "source": path.name,
+                "cts": cts, "passage": passage,
+            })
+            if not normalize(text):
+                continue
+            row = Sentence(
+                source=source, source_file=path.name, source_sentence_id=sid,
+                author=author, work=work, work_id=work_id, text=text, conllu=conllu,
+                cts_urn=cts, passage=passage, genre=genre, native_cites=cites,
+                priority={"gorman": 5, "harrington": 15, "pedalion": 20}.get(source, 20),
+            )
+            row.source_records = [source_record(source, revisions, path.name, sid)]
+            (verse if genre == "verse" else prose).append(row)
+    return prose, verse
+
+
+def publication_metadata(config_path: Path) -> dict[str, tuple[str, str]]:
+    config = json.loads(config_path.read_text())
+    result = {}
+
+    def visit(value):
+        if isinstance(value, dict):
+            if "author" in value and "work" in value:
+                for section in value.get("sections", []):
+                    xml = section.get("xml", "")
+                    if xml:
+                        result[Path(xml).name] = (value["author"], value["work"])
+            for child in value.values():
+                visit(child)
+        elif isinstance(value, list):
+            for child in value:
+                visit(child)
+
+    visit(config)
+    return result
+
+
+class HypotacticParser(HTMLParser):
+    def __init__(self, stem: str):
+        super().__init__(convert_charrefs=True)
+        self.stem = stem
+        self.container = {}
+        self.depth = 0
+        self.line_depth = None
+        self.line = None
+        self.word_depth = None
+        self.word_text = []
+        self.syll_depth = None
+        self.syllable = None
+        self.lines = []
+
+    def handle_starttag(self, tag, attrs):
+        self.depth += 1
+        attrs = dict(attrs)
+        classes = set(attrs.get("class", "").split())
+        if tag == "div" and self.line is None and "line" not in classes:
+            for key in ("data-author", "data-work", "data-book", "data-metre"):
+                if key in attrs and key not in self.container:
+                    self.container[key] = attrs[key]
+        if tag == "div" and "line" in classes:
+            self.line_depth = self.depth
+            self.line = {
+                "number": attrs.get("data-number", ""),
+                "metre": attrs.get("data-metre", self.container.get("data-metre", "")),
+                "speaker": attrs.get("data-speaker", ""),
+                "words": [], "syllables": [],
+            }
+        elif self.line is not None and tag == "span" and "word" in classes:
+            self.word_depth = self.depth
+            self.word_text = []
+        if self.line is not None and tag == "span" and "syll" in classes:
+            quantity = "long" if "long" in classes else "short" if "short" in classes else "anceps" if "anceps" in classes else "unknown"
+            self.syll_depth = self.depth
+            self.syllable = {
+                "text": "", "quantity": quantity,
+                "features": sorted(classes - {"syll", "long", "short", "anceps"}),
+            }
+
+    def handle_data(self, data):
+        if self.word_depth is not None:
+            self.word_text.append(data)
+        if self.syllable is not None:
+            self.syllable["text"] += data
+
+    def handle_endtag(self, tag):
+        if self.syll_depth == self.depth and self.syllable is not None:
+            self.line["syllables"].append(self.syllable)
+            self.syllable = None
+            self.syll_depth = None
+        if self.word_depth == self.depth and tag == "span":
+            word = "".join(self.word_text).strip()
+            if word:
+                self.line["words"].append(word)
+            self.word_depth = None
+            self.word_text = []
+        if self.line_depth == self.depth and tag == "div":
+            self.line["text"] = " ".join(self.line.pop("words"))
+            symbols = {"long": "–", "short": "⏑", "anceps": "×", "unknown": "?"}
+            self.line["scansion"] = "".join(symbols[s["quantity"]] for s in self.line["syllables"])
+            self.line["hypotactic_file"] = self.stem + ".html"
+            self.line.update({
+                "hypotactic_author": self.container.get("data-author", ""),
+                "hypotactic_work": self.container.get("data-work", ""),
+                "book": self.container.get("data-book", ""),
+            })
+            if self.line["text"] and self.line["number"]:
+                self.lines.append(self.line)
+            self.line = None
+            self.line_depth = None
+        self.depth -= 1
+
+
+def parse_hypotactic_file(path: Path) -> list[dict]:
+    parser = HypotacticParser(path.stem)
+    parser.feed(path.read_text(encoding="utf8"))
+    # Older files do not carry book metadata; recover it from their stem.
+    book_match = re.match(r"(?:iliad|odyssey|dionysiaca|qsmyrnaeus)(\d+)$", path.stem)
+    for line in parser.lines:
+        if not line["book"] and book_match:
+            line["book"] = book_match.group(1)
+        line["normalized"] = normalize(line["text"])
+    return parser.lines
+
+
+def load_hypotactic(root: Path) -> dict[str, list[dict]]:
+    html_root = root / "hypotactic_htmls_greek"
+    needed = sorted({stem for link in VERSE_LINKS.values() for stem in link["files"]})
+    return {stem: parse_hypotactic_file(html_root / f"{stem}.html") for stem in needed}
+
+
+def line_reference_index(lines: list[dict]) -> dict[str, list[dict]]:
+    index = defaultdict(list)
+    for line in lines:
+        index[line["number"]].append(line)
+        if line["book"]:
+            index[f"{line['book']}.{line['number']}"].append(line)
+    return index
+
+
+def candidate_lines(
+    sentence: Sentence,
+    lines: list[dict],
+    reference_index: dict[str, list[dict]] | None = None,
+) -> list[dict]:
+    sentence_norm = sentence.normalized
+    if not sentence_norm:
+        return []
+    cited = set()
+    for cite in sentence.native_cites:
+        ref = cite.rsplit(":", 1)[-1]
+        cited.add(ref)
+        if ref.startswith("1.") and sentence.work_id.startswith("tlg0020"):
+            cited.add(ref[2:])
+    candidates = lines
+    if cited:
+        reference_index = reference_index or line_reference_index(lines)
+        selected = []
+        seen = set()
+        for ref in cited:
+            for line in reference_index.get(ref, []):
+                marker = (line["hypotactic_file"], line["number"])
+                if marker not in seen:
+                    seen.add(marker)
+                    selected.append(line)
+        if selected:
+            candidates = selected
+    found = [
+        line for line in candidates
+        if line["normalized"] and line["normalized"] in sentence_norm
+    ]
+    if found or candidates is lines:
+        return found
+    # Some original CTS citations use a different line numbering from the
+    # Hypotactic edition (Prometheus Bound is the conspicuous case).  Exact
+    # full-line containment remains safe, so fall back to all lines.
+    return [
+        line for line in lines
+        if line["normalized"] and line["normalized"] in sentence_norm
+    ]
+
+
+def align_verse(verse_sentences: list[Sentence], hyp: dict[str, list[dict]], revisions: dict[str, str]) -> tuple[list[dict], list[dict], dict]:
+    sentence_rows, metre_rows = [], []
+    alignment_stats = defaultdict(lambda: Counter(sentences=0, matched_sentences=0, matched_lines=0))
+    seen_lines = set()
+    line_cache = {}
+    index_cache = {}
+    for link_key, link in VERSE_LINKS.items():
+        lines = [line for stem in link["files"] for line in hyp[stem]]
+        line_cache[link_key] = lines
+        index_cache[link_key] = line_reference_index(lines)
+    for sentence in verse_sentences:
+        link_key = sentence.work_id
+        if sentence.source == "pedalion":
+            link_key = f"pedalion:{sentence.source_file}"
+        link = VERSE_LINKS.get(link_key)
+        if not link:
+            continue
+        lines = line_cache[link_key]
+        stats = alignment_stats[link_key]
+        stats["sentences"] += 1
+        matched = candidate_lines(sentence, lines, index_cache[link_key])
+        if not matched:
+            continue
+        stats["matched_sentences"] += 1
+        stats["matched_lines"] += len(matched)
+        row_id = "vs-" + stable_id(sentence.source, sentence.source_file, sentence.source_sentence_id)
+        lines_by_file = defaultdict(list)
+        for line in matched:
+            lines_by_file[line["hypotactic_file"]].append(line)
+        source_records = list(sentence.source_records) + [
+            source_record(
+                "hypotactic", revisions, source_file,
+                ",".join(f"{line['book']}:{line['number']}" for line in file_lines),
+            )
+            for source_file, file_lines in sorted(lines_by_file.items())
+        ]
+        sentence_rows.append({
+            "id": row_id, "author": sentence.author, "work": sentence.work,
+            "work_id": sentence.work_id, "genre": "verse_sentence", "text": sentence.text,
+            "conllu": sentence.conllu, "cts_urn": sentence.cts_urn, "passage": sentence.passage,
+            "metre": sorted({line["metre"] for line in matched}),
+            "metrical_lines": json.dumps([{k: v for k, v in line.items() if k != "normalized"} for line in matched], ensure_ascii=False),
+            "treebank_source": sentence.source,
+            "source_records": json.dumps(source_records, ensure_ascii=False, sort_keys=True),
+            "licenses": sorted({record["license"] for record in source_records}),
+            "dedup_key": hashlib.sha256(sentence.normalized.encode()).hexdigest(),
+        })
+        for line in matched:
+            logical_line = (sentence.work_id, line["hypotactic_file"], line["number"])
+            if logical_line in seen_lines:
+                continue
+            seen_lines.add(logical_line)
+            line_source_records = list(sentence.source_records) + [source_record(
+                "hypotactic", revisions, line["hypotactic_file"],
+                f"{line['book']}:{line['number']}",
+            )]
+            metre_rows.append({
+                "id": "vm-" + stable_id(*logical_line), "parent_sentence_id": row_id,
+                "author": sentence.author, "work": sentence.work, "work_id": sentence.work_id,
+                "genre": "verse_metre", "text": line["text"], "conllu": sentence.conllu,
+                "cts_urn": sentence.cts_urn, "passage": sentence.passage,
+                "book": line["book"], "line_number": line["number"], "metre": line["metre"],
+                "scansion": line["scansion"],
+                "syllables": json.dumps(line["syllables"], ensure_ascii=False),
+                "hypotactic_file": line["hypotactic_file"], "treebank_source": sentence.source,
+                "source_records": json.dumps(line_source_records, ensure_ascii=False, sort_keys=True),
+                "licenses": sorted({record["license"] for record in line_source_records}),
+                "dedup_key": hashlib.sha256(line["normalized"].encode()).hexdigest(),
+            })
+    return sentence_rows, metre_rows, {key: dict(value) for key, value in alignment_stats.items()}
+
+
+def deduplicate_prose(rows: list[Sentence]) -> tuple[list[dict], dict]:
+    groups = defaultdict(list)
+    for row in rows:
+        if row.normalized:
+            groups[hashlib.sha256(row.normalized.encode()).hexdigest()].append(row)
+    output = []
+    duplicate_groups = 0
+    duplicate_rows = 0
+    conflicting_author_groups = 0
+    conflicting_author_rows = 0
+    conflict_examples = []
+    for key, members in groups.items():
+        authors = {canonical_author(member.author) for member in members}
+        if len(authors) > 1:
+            conflicting_author_groups += 1
+            conflicting_author_rows += len(members)
+            if len(conflict_examples) < 25:
+                conflict_examples.append({
+                    "dedup_key": key,
+                    "authors": sorted(authors),
+                    "normalized_length": len(members[0].normalized),
+                    "sources": sorted({member.source for member in members}),
+                })
+            continue
+        members.sort(key=lambda row: (row.priority, row.source, row.source_file, row.source_sentence_id))
+        chosen = members[0]
+        source_records = []
+        seen = set()
+        for member in members:
+            for record in member.source_records:
+                record_key = (record["source"], record["source_file"], record["source_sentence_id"])
+                if record_key not in seen:
+                    seen.add(record_key)
+                    source_records.append(record)
+        if len(members) > 1:
+            duplicate_groups += 1
+            duplicate_rows += len(members) - 1
+        output.append({
+            "id": "p-" + stable_id(chosen.source, chosen.source_file, chosen.source_sentence_id),
+            "author": chosen.author, "work": chosen.work, "work_id": chosen.work_id,
+            "genre": "prose", "text": chosen.text, "conllu": chosen.conllu,
+            "cts_urn": chosen.cts_urn, "passage": chosen.passage,
+            "treebank_source": chosen.source,
+            "source_records": json.dumps(source_records, ensure_ascii=False, sort_keys=True),
+            "licenses": sorted({record["license"] for record in source_records}),
+            "dedup_key": key,
+        })
+    output.sort(key=lambda row: row["id"])
+    return output, {
+        "input_rows": len(rows), "output_rows": len(output),
+        "duplicate_groups": duplicate_groups, "removed_exact_duplicates": duplicate_rows,
+        "conflicting_author_groups_removed": conflicting_author_groups,
+        "conflicting_author_rows_removed": conflicting_author_rows,
+        "conflict_examples": conflict_examples,
+    }
+
+
+def assign_splits(rows: list[dict], parent_splits: dict[str, str] | None = None) -> None:
+    if parent_splits is not None:
+        for row in rows:
+            row["split"] = parent_splits[row["parent_sentence_id"]]
+        return
+    groups = defaultdict(list)
+    for row in rows:
+        groups[(row["author"], row["work_id"])].append(row)
+    for group_rows in groups.values():
+        group_rows.sort(key=lambda row: hashlib.sha256(row["id"].encode()).hexdigest())
+        n = len(group_rows)
+        if n < 3:
+            n_val = n_test = 0
+        elif n < 10:
+            n_val = n_test = 1
+        else:
+            n_val = max(1, round(n * 0.1))
+            n_test = max(1, round(n * 0.1))
+        for index, row in enumerate(group_rows):
+            row["split"] = "validation" if index < n_val else "test" if index < n_val + n_test else "train"
+
+
+def write_parquet(rows: list[dict], output_root: Path, config: str) -> dict:
+    stats = {}
+    config_root = output_root / config
+    config_root.mkdir(parents=True, exist_ok=True)
+    for split in ("train", "validation", "test"):
+        split_rows = [row for row in rows if row["split"] == split]
+        table = pa.Table.from_pylist(split_rows)
+        path = config_root / f"{split}-00000-of-00001.parquet"
+        pq.write_table(table, path, compression="zstd", compression_level=9)
+        stats[split] = len(split_rows)
+    return stats
+
+
+def validate(rows_by_config: dict[str, list[dict]]) -> dict:
+    report = {}
+    for config, rows in rows_by_config.items():
+        ids = [row["id"] for row in rows]
+        dedup = [row["dedup_key"] for row in rows]
+        assert len(ids) == len(set(ids)), f"duplicate ids in {config}"
+        assert all(row["genre"] == config for row in rows)
+        assert all(row["text"] and row["author"] and row["work"] for row in rows)
+        assert all(row["split"] in {"train", "validation", "test"} for row in rows)
+        if config == "prose":
+            assert len(dedup) == len(set(dedup)), "prose exact-text deduplication failed"
+        report[config] = {
+            "rows": len(rows),
+            "authors": len({row["author"] for row in rows}),
+            "works": len({row["work_id"] for row in rows}),
+            "sources": dict(Counter(row["treebank_source"] for row in rows)),
+            "splits": dict(Counter(row["split"] for row in rows)),
+        }
+    parent_splits = {row["id"]: row["split"] for row in rows_by_config["verse_sentence"]}
+    assert all(parent_splits[row["parent_sentence_id"]] == row["split"] for row in rows_by_config["verse_metre"])
+    report["checks"] = {
+        "unique_ids": True, "prose_exact_text_unique": True,
+        "verse_parent_split_consistency": True,
+    }
+    return report
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--sources", type=Path, required=True)
+    parser.add_argument("--output", type=Path, default=Path("data"))
+    parser.add_argument("--metadata", type=Path, default=Path("metadata"))
+    args = parser.parse_args()
+
+    revisions = {
+        key: git_revision(args.sources / info["directory"])
+        for key, info in SOURCE_INFO.items()
+    }
+
+    agdt_prose, agdt_verse = parse_agdt(args.sources / "treebank_data", revisions)
+    ud_perseus_prose, _ = parse_ud("ud_perseus", args.sources / "perseus", revisions)
+    proiel_prose, _ = parse_ud("ud_proiel", args.sources / "proiel", revisions)
+    ptnk_prose, _ = parse_ud("ud_ptnk", args.sources / "ptnk", revisions)
+
+    gorman_prose, _ = parse_native_collection(
+        "gorman", (args.sources / "gorman" / "xml versions").glob("*.xml"), revisions,
+    )
+    pedalion_meta = publication_metadata(args.sources / "pedalion" / "src" / "config.json")
+    # The Pedalion card groups these three files under "diverse authors";
+    # restore the file-level attributions encoded in the XML.
+    pedalion_meta.update({
+        "semonides.xml": ("Semonides", "Typology of Women"),
+        "theoc.xml": ("Theocritus", "Fragments"),
+        "mimn.xml": ("Mimnermus", "Fragments"),
+    })
+    pedalion_files = [
+        path for path in (args.sources / "pedalion" / "public" / "xml").glob("*.xml")
+        if path.name not in PEDALION_EXCLUDE
+    ]
+    pedalion_prose, pedalion_verse = parse_native_collection(
+        "pedalion", pedalion_files, revisions, pedalion_meta, PEDALION_VERSE,
+    )
+    harrington_meta = publication_metadata(args.sources / "harrington" / "src" / "config.json")
+    harrington_prose, _ = parse_native_collection(
+        "harrington",
+        (args.sources / "harrington" / "public" / "xml" / "CITE_TREEBANK_XML" / "perseus" / "grctb").rglob("*.xml"),
+        revisions, harrington_meta,
+    )
+
+    prose_input = (
+        ud_perseus_prose + proiel_prose + ptnk_prose + agdt_prose + gorman_prose
+        + pedalion_prose + harrington_prose
+    )
+    prose, dedup_stats = deduplicate_prose(prose_input)
+    assign_splits(prose)
+
+    hyp = load_hypotactic(args.sources / "hypotactic")
+    verse_sentence, verse_metre, alignment_stats = align_verse(
+        agdt_verse + pedalion_verse, hyp, revisions,
+    )
+    assign_splits(verse_sentence)
+    parent_splits = {row["id"]: row["split"] for row in verse_sentence}
+    assign_splits(verse_metre, parent_splits)
+
+    rows_by_config = {
+        "prose": prose, "verse_sentence": verse_sentence, "verse_metre": verse_metre,
+    }
+    validation = validate(rows_by_config)
+
+    data_stats = {
+        config: write_parquet(rows, args.output, config)
+        for config, rows in rows_by_config.items()
+    }
+    args.metadata.mkdir(parents=True, exist_ok=True)
+    (args.metadata / "source_revisions.json").write_text(
+        json.dumps({
+            key: {**SOURCE_INFO[key], "revision": revision}
+            for key, revision in revisions.items()
+        }, indent=2, ensure_ascii=False) + "\n"
+    )
+    (args.metadata / "build_report.json").write_text(json.dumps({
+        "data_files": data_stats,
+        "deduplication": dedup_stats,
+        "alignment": alignment_stats,
+        "validation": validation,
+        "excluded": {
+            "aphthonius": "No redistribution license is specified upstream.",
+            "pedalion_mixed": sorted(PEDALION_EXCLUDE),
+            "harrington_grctb_805": "File declares xml:lang=lat and contains Cicero despite its grctb path.",
+        },
+    }, indent=2, ensure_ascii=False, sort_keys=True) + "\n")
+    print(json.dumps(validation, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_dataset.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Independent validation for the published Sphregis Parquet files."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import unicodedata
+from collections import Counter
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+
+CONFIGS = ("prose", "verse_sentence", "verse_metre")
+SPLITS = ("train", "validation", "test")
+
+
+LIGHT_COLUMNS = [
+    "id", "parent_sentence_id", "author", "work", "genre", "text",
+    "dedup_key", "split",
+]
+
+
+def read_config(root: Path, config: str) -> list[dict]:
+    rows = []
+    for split in SPLITS:
+        path = root / config / f"{split}-00000-of-00001.parquet"
+        assert path.is_file(), f"missing {path}"
+        parquet = pq.ParquetFile(path)
+        columns = [name for name in LIGHT_COLUMNS if name in parquet.schema.names]
+        part = parquet.read(columns=columns, use_threads=False).to_pylist()
+        assert all(row["split"] == split for row in part), f"split label mismatch in {path}"
+        rows.extend(part)
+    return rows
+
+
+def normalize(text: str) -> str:
+    text = text.lower().replace("ς", "σ")
+    text = "".join(
+        char for char in unicodedata.normalize("NFD", text)
+        if unicodedata.category(char) != "Mn"
+    )
+    return "".join(char for char in text if char.isalpha())
+
+
+def validate_provenance_and_verse(root: Path, parent_texts: dict[str, str]) -> int:
+    checked_lines = 0
+    required_record_fields = {
+        "source", "source_file", "source_sentence_id", "url", "revision",
+        "license", "annotation_provenance", "syntax_scheme",
+    }
+    for config in CONFIGS:
+        for split in SPLITS:
+            path = root / config / f"{split}-00000-of-00001.parquet"
+            columns = ["source_records", "licenses"]
+            if config == "verse_sentence":
+                columns += ["text", "metrical_lines"]
+            elif config == "verse_metre":
+                columns += [
+                    "parent_sentence_id", "text", "metre", "scansion",
+                    "syllables", "hypotactic_file",
+                ]
+            parquet = pq.ParquetFile(path)
+            for batch in parquet.iter_batches(columns=columns, batch_size=256, use_threads=False):
+                for row in batch.to_pylist():
+                    records = json.loads(row["source_records"])
+                    assert records and all(required_record_fields <= record.keys() for record in records)
+                    assert all(re.fullmatch(r"[0-9a-f]{40}", record["revision"]) for record in records)
+                    assert sorted(row["licenses"]) == sorted({record["license"] for record in records})
+                    if config == "verse_sentence":
+                        lines = json.loads(row["metrical_lines"])
+                        sentence_text = normalize(row["text"])
+                        assert lines and all(normalize(line["text"]) in sentence_text for line in lines)
+                        assert all(line["metre"] and line["scansion"] and line["syllables"] for line in lines)
+                    elif config == "verse_metre":
+                        assert normalize(row["text"]) in normalize(parent_texts[row["parent_sentence_id"]])
+                        syllables = json.loads(row["syllables"])
+                        assert row["metre"] and row["scansion"] and syllables
+                        hyp_records = [record for record in records if record["source"] == "hypotactic"]
+                        assert len(hyp_records) == 1
+                        assert hyp_records[0]["source_file"] == row["hypotactic_file"]
+                        checked_lines += 1
+    return checked_lines
+
+
+def validate_conllu(root: Path) -> int:
+    checked = 0
+    for config in ("prose", "verse_sentence"):
+        for split in SPLITS:
+            path = root / config / f"{split}-00000-of-00001.parquet"
+            parquet = pq.ParquetFile(path)
+            for batch in parquet.iter_batches(columns=["conllu"], batch_size=256, use_threads=False):
+                for conllu in batch.column(0).to_pylist():
+                    token_rows = [
+                        line.split("\t") for line in conllu.splitlines()
+                        if line and not line.startswith("#") and re.fullmatch(r"\d+", line.split("\t", 1)[0])
+                    ]
+                    assert token_rows and all(len(row) == 10 for row in token_rows)
+                    ids = [int(row[0]) for row in token_rows]
+                    assert ids == list(range(1, len(ids) + 1))
+                    heads = [int(row[6]) for row in token_rows]
+                    assert all(0 <= head <= len(ids) for head in heads)
+                    assert all(token_id != head for token_id, head in zip(ids, heads))
+                    assert sum(head == 0 for head in heads) == 1
+                    assert sum(row[7] == "root" for row in token_rows) == 1
+                    assert all((head == 0) == (row[7] == "root") for row, head in zip(token_rows, heads))
+                    for token_id in ids:
+                        visited = set()
+                        cursor = token_id
+                        while cursor:
+                            assert cursor not in visited, "dependency cycle"
+                            visited.add(cursor)
+                            cursor = heads[cursor - 1]
+                    checked += 1
+    return checked
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data", type=Path, default=Path("data"))
+    args = parser.parse_args()
+    configs = {config: read_config(args.data, config) for config in CONFIGS}
+    for config, rows in configs.items():
+        ids = [row["id"] for row in rows]
+        assert len(ids) == len(set(ids)), f"duplicate IDs in {config}"
+        assert all(row["genre"] == config for row in rows)
+        assert all(row["text"] and row["author"] and row["work"] for row in rows)
+        if config == "prose":
+            keys = [row["dedup_key"] for row in rows]
+            assert len(keys) == len(set(keys)), "prose is not exactly deduplicated"
+        print(config, len(rows), dict(Counter(row["split"] for row in rows)))
+    sentence_splits = {row["id"]: row["split"] for row in configs["verse_sentence"]}
+    assert all(
+        sentence_splits[row["parent_sentence_id"]] == row["split"]
+        for row in configs["verse_metre"]
+    ), "verse sentence/metre split leakage"
+    parent_texts = {row["id"]: row["text"] for row in configs["verse_sentence"]}
+    checked_lines = validate_provenance_and_verse(args.data, parent_texts)
+    checked = validate_conllu(args.data)
+    print("validated aligned metrical lines", checked_lines)
+    print("validated CoNLL-U sentences", checked)
+    print("all checks passed")
+
+
+if __name__ == "__main__":
+    main()