Add lc0 self-play and Lichess Elite position collections

Adds two unlabeled position collections in the existing schema:
lc0_selfplay (2,000,000 positions, 9 lc0 runs, split by network strength) and lichess_elite (300,000 positions, 12 months of the Lichess Elite Database).
Includes variance reports and the build scripts.

README.md

@@ -12,6 +12,8 @@ tags:
 - fen
 - lc0
 - wdl
+- self-play
+- lichess
 
 size_categories:
 - 1M<n<10M
@@ -36,28 +38,56 @@ configs:
     path: zero-consensus/validation-*.parquet
   - split: test
     path: zero-consensus/test-*.parquet
+- config_name: lc0_selfplay
+  data_files:
+  - split: strong
+    path: lc0-selfplay-2m/source_split=strong/**/*.parquet
+  - split: mid
+    path: lc0-selfplay-2m/source_split=mid/**/*.parquet
+  - split: low
+    path: lc0-selfplay-2m/source_split=low/**/*.parquet
+  - split: early
+    path: lc0-selfplay-2m/source_split=early/**/*.parquet
+- config_name: lichess_elite
+  data_files:
+  - split: train
+    path: lichess-elite-300k/source_split=human/**/*.parquet
 ---
 
 # Zero Evaluator High-Variance Chess Positions
 
-This dataset contains **1,509,201 unique chess positions** extracted from Leela
-Chess Zero's published CCRL standard corpus. Positions are stored as normalized
-six-field FEN records for immediate board reconstruction without replaying a
-game.
+This dataset collects **3,809,201 chess positions** from three distinct styles
+of play — engine tournament games, neural-network self-play, and strong human
+online games. Positions are stored as normalized six-field FEN records for
+immediate board reconstruction without replaying a game, and every collection
+balances opening, middlegame, and endgame coverage.
+
+Two of the collections additionally carry static, depth-zero win/draw/loss
+labels. Variance audits are in `variance-report.json`,
+`lc0-selfplay-2m-variance.json`, `lichess-elite-300k-variance.json`, and
+`RESULTS.md`.
 
-The selection deliberately balances opening, middlegame, and endgame coverage
-and retains the original source train/test split. The complete variance audit
-is in `variance-report.json` and `RESULTS.md`.
+Five configurations are available.
 
-Three configurations are available:
+Positions with labels:
 
-- `default`: the original unlabeled positions;
-- `stockfish_zero_wdl`: the same positions with immediate static Stockfish
-  NNUE WDL labels and per-row engine provenance;
+- `stockfish_zero_wdl`: 1,509,201 CCRL positions with immediate static
+  Stockfish NNUE WDL labels and per-row engine provenance;
 - `consensus_wdl`: a one-million-position subset carrying calibrated static WDL
   from both Lc0 and Stockfish, a blended consensus target, and a per-row
   agreement weight.
 
+Positions without labels:
+
+- `default`: 1,509,201 positions from CCRL engine tournament games;
+- `lc0_selfplay`: 2,000,000 positions from Leela Chess Zero self-play,
+  split by the generation strength of the network that produced them;
+- `lichess_elite`: 300,000 positions from strong human games on Lichess.
+
+The three unlabeled collections are near-disjoint: of 3,809,201 rows,
+3,784,379 FENs are unique and 24,822 appear in more than one collection,
+almost entirely common opening positions.
+
 ## Data layout
 
 The release consists of six Zstandard-compressed Parquet files partitioned by:
@@ -246,6 +276,73 @@ row = positions["train"][0]
 print(row["fen"], row["wdl_win"], row["sample_weight"])
 ```
 
+## Self-play and human position collections
+
+Two further collections extend the corpus beyond CCRL engine games. Both hold
+positions only — no evaluations — in the same schema as the `default`
+configuration, so they can be read the same way and labeled independently.
+
+### `lc0_selfplay`
+
+2,000,000 positions sampled from Leela Chess Zero self-play training data
+published at `storage.lczero.org/files/training_data`, drawn from 252,686
+distinct games across 56 archives and 9 training runs spanning 2018-09 to
+2026-08.
+
+Splits correspond to the strength of the network that generated the games,
+since a collection drawn only from the strongest run would be narrow in exactly
+the way a varied corpus should not be:
+
+| Split | Positions | Runs | Character |
+| --- | ---: | --- | --- |
+| `strong` | 1,200,000 | test80, test91 | Mature run1 and the live run2 |
+| `mid` | 440,000 | test79, test75, late test60 | Transitional styles, sound but more varied |
+| `low` | 260,000 | test40, early test60, test71_5 | Messier tactics, unusual structures |
+| `early` | 100,000 | test30, run3 | Semi-initial play, maximum noise |
+
+Records were decoded with the Lc0 rescorer without tablebase rescoring or
+deblundering, and without the position filtering that the Stockfish NNUE
+conversion path applies. Up to twelve positions were taken per game, allocated
+across phases in the same 15/60/25 ratio the splits hold.
+
+The `test71` run is excluded: it is the Chess960 run, measured at 30-36%
+Chess960 against at most 1.2% in every other run. Chess960 positions are
+excluded throughout, so every FEN is legal standard chess.
+
+Source game results are 583,358 white wins, 893,297 draws, and 523,345 black
+wins — a 44.7% draw rate.
+
+### `lichess_elite`
+
+300,000 positions from 180,510 games in the
+[Lichess Elite Database](https://database.nikonoel.fr/), which filters the
+Lichess standard database to games where a 2400+ player faced a 2200+ player.
+Twelve months are sampled in equal share, spread across 2020-06 to 2025-10, at
+three positions per game.
+
+This is strong human **blitz**, not considered classical play: roughly 88% of
+eligible games are 3+0 or 3+2, 5% rapid, and under 1% classical, with White Elo
+median 2550. Bullet and ultrabullet are excluded.
+
+Draws are 12.3% of source games here, against 44.7% in `lc0_selfplay`. Human
+blitz is substantially more decisive than engine self-play, so this collection
+supplies sharper and less balanced positions than the other two.
+
+### Loading
+
+```python
+from datasets import load_dataset
+
+selfplay = load_dataset("Pawitt/zero-evaluator", "lc0_selfplay")
+print(selfplay["strong"][0]["fen"])
+
+human = load_dataset("Pawitt/zero-evaluator", "lichess_elite")
+print(human["train"][0]["fen"])
+```
+
+Both use the same columns as `default`; see `FORMAT.md`. As there, the source
+game `result` is provenance metadata and not a position label.
+
 ## Validation
 
 - All 1,509,201 source rows were reproduced in Parquet.
@@ -264,6 +361,15 @@ print(row["fen"], row["wdl_win"], row["sample_weight"])
   shards, each matching its manifest row count and SHA-256 checksum.
 - Every consensus row carries three WDL triples that each sum to 1000, and a
   sample weight within `[0.4, 1.0]`.
+- The self-play and human collections contain exactly 2,000,000 and 300,000
+  rows, with no duplicate FEN within either.
+- Their Parquet forms hold FEN sets identical to the SQLite databases they were
+  built from.
+- Sampled rows from both were reconstructed with python-chess: every FEN parses
+  as a legal standard-chess position, and `side_to_move`, `piece_count`,
+  `in_check`, and `legal_moves` were recomputed and matched.
+- Every split in both holds opening, middlegame, and endgame in a 15/60/25
+  ratio.
 
 ## Source
 
@@ -271,4 +377,11 @@ The source is the [Leela Chess Zero standard CCRL dataset](https://lczero.org/bl
 published as 2.5 million CCRL 40/40 and 40/4 engine games with an original
 80/20 train/test split.
 
+The self-play collection derives from
+[Lc0 training data](https://storage.lczero.org/files/training_data/), decoded
+with the [Lc0 rescorer](https://github.com/Tilps/lc0/tree/rescore_tb). The human
+collection derives from the
+[Lichess Elite Database](https://database.nikonoel.fr/), itself filtered from
+the [Lichess open database](https://database.lichess.org/).
+
 The extraction and conversion scripts are included for reproducibility.

lc0-selfplay-2m-variance.json

@@ -0,0 +1,93 @@
+{
+  "database": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/data/lc0-selfplay-2m.vpd",
+  "database_bytes": 680898560,
+  "distributions": {
+    "in_check": 119989,
+    "material_imbalance_abs_ge_3": 394136,
+    "phase": {
+      "endgame": 499999,
+      "middlegame": 1200001,
+      "opening": 300000
+    },
+    "result": {
+      "0-1": 523345,
+      "1-0": 583358,
+      "1/2-1/2": 893297
+    },
+    "side_to_move": {
+      "black": 1004042,
+      "white": 995958
+    },
+    "source_split": {
+      "early": 100000,
+      "low": 260000,
+      "mid": 440000,
+      "strong": 1200000
+    },
+    "with_castling_rights": 582149,
+    "without_castling_rights": 1417851
+  },
+  "format": "VPD1",
+  "high_variance": true,
+  "metadata": {
+    "completed_unix": "1787660503",
+    "corpus": "lc0-selfplay-tiered",
+    "excluded_runs": "{\"test71\": \"Chess960 run; 30-36% of positions are Chess960\", \"test78\": \"all tars are 10 KB placeholders\", \"test90\": \"all tars are 10 KB placeholders\"}",
+    "fen_fullmove_normalization": "1",
+    "format": "VPD1",
+    "keep_chess960": "0",
+    "per_game": "12",
+    "position_count": "2000000",
+    "seed": "91",
+    "slice_bytes": "120000000",
+    "source": "https://storage.lczero.org/files/training_data",
+    "target_positions": "2000000",
+    "tars_done": "[\"run3/training-run3-20190615-0720.tar\", \"run3/training-run3-20190707-1318.tar\", \"run3/training-run3-20190818-0817.tar\", \"test30/training-run2-20180909-1221.tar\", \"test30/training-run2-20181214-1617.tar\", \"test40/training-run1-20190108-1117.tar\", \"test40/training-run1-20190710-1317.tar\", \"test60/training-run1-20190726-1317.tar\", \"test60/training-run1-20191024-0917.tar\", \"test60/training-run1-20200119-2117.tar\", \"test60/training-run1-test60-20210108-1117.tar\", \"test60/training-run1-test60-20210404-2117.tar\", \"test60/training-run1-test60-20210706-0917.tar\", \"test60/training-run1-test60-20220102-0317.tar\", \"test71_5/training-run3-test71_5-20200705-0821.tar\", \"test71_5/training-run3-test71_5-20200821-1829.tar\", \"test75/training-run3-test75-20210314-0535.tar\", \"test75/training-run3-test75-20210426-0227.tar\", \"test75/training-run3-test75-20210609-1028.tar\", \"test75/training-run3-test75-20210730-0317.tar\", \"test75/training-run3-test75-20210911-0217.tar\", \"test79/training-run2-test79-20220225-0617.tar\", \"test79/training-run2-test79-20220318-1517.tar\", \"test79/training-run2-test79-20220408-2320.tar\", \"test79/training-run2-test79-20220430-2321.tar\", \"test80/training-run1-test80-20240401-0017.tar\", \"test80/training-run1-test80-20240411-1617.tar\", \"test80/training-run1-test80-20240422-1217.tar\", \"test80/training-run1-test80-20240514-0717.tar\", \"test80/training-run1-test80-20240604-1517.tar\", \"test80/training-run1-test80-20240626-0817.tar\", \"test80/training-run1-test80-20240718-1917.tar\", \"test80/training-run1-test80-20240809-0317.tar\", \"test80/training-run1-test80-20240830-1217.tar\", \"test80/training-run1-test80-20240920-2017.tar\", \"test80/training-run1-test80-20241012-0417.tar\", \"test80/training-run1-test80-20241102-1217.tar\", \"test80/training-run1-test80-20241207-2317.tar\", \"test80/training-run1-test80-20241229-0717.tar\", \"test80/training-run1-test80-20250211-2317.tar\", \"test80/training-run1-test80-20250308-0217.tar\", \"test80/training-run1-test80-20250329-1017.tar\", \"test80/training-run1-test80-20250419-1917.tar\", \"test80/training-run1-test80-20250723-0017.tar\", \"test80/training-run1-test80-20250813-0917.tar\", \"test91/training-run2-test91-20251220-0017.tar\", \"test91/training-run2-test91-20260102-1517.tar\", \"test91/training-run2-test91-20260113-0718.tar\", \"test91/training-run2-test91-20260209-0417.tar\", \"test91/training-run2-test91-20260308-0817.tar\", \"test91/training-run2-test91-20260403-1317.tar\", \"test91/training-run2-test91-20260503-0517.tar\", \"test91/training-run2-test91-20260524-2017.tar\", \"test91/training-run2-test91-20260615-0617.tar\", \"test91/training-run2-test91-20260718-2017.tar\", \"test91/training-run2-test91-20260810-0917.tar\"]",
+    "tier_quotas": "{\"early\": 100000, \"low\": 260000, \"mid\": 440000, \"strong\": 1200000}"
+  },
+  "normalized_phase_entropy": 0.853474,
+  "numeric": {
+    "legal_moves": {
+      "max": 81,
+      "mean": 30.4465,
+      "median": 32,
+      "min": 1,
+      "p10": 14,
+      "p90": 44,
+      "stdev": 11.6261
+    },
+    "material_balance_white_minus_black": {
+      "max": 44,
+      "mean": 0.007,
+      "median": 0,
+      "min": -43,
+      "p10": -2,
+      "p90": 2,
+      "stdev": 3.8089
+    },
+    "piece_count": {
+      "max": 32,
+      "mean": 21.2929,
+      "median": 22,
+      "min": 3,
+      "p10": 11,
+      "p90": 31,
+      "stdev": 7.5803
+    }
+  },
+  "positions": 2000000,
+  "thresholds": {
+    "at_least_1_5m_positions": true,
+    "both_castling_states_at_least_10pct": true,
+    "checks_at_least_1pct": true,
+    "legal_move_p10_at_most_22": true,
+    "legal_move_p90_at_least_38": true,
+    "legal_move_stdev_at_least_8": true,
+    "material_imbalance_at_least_15pct": true,
+    "phase_entropy_at_least_0_85": true,
+    "phase_min_share_at_least_15pct": true,
+    "piece_count_stdev_at_least_5": true,
+    "result_min_share_at_least_20pct": true,
+    "side_to_move_between_47_and_53pct_white": true
+  }
+}

lc0-selfplay-2m/_manifest.json

@@ -0,0 +1,148 @@
+{
+  "compression": "zstd",
+  "compression_level": 6,
+  "elapsed_seconds": 6.299,
+  "format": "VPD1-Parquet",
+  "partitioning": [
+    "source_split",
+    "phase"
+  ],
+  "partitions": [
+    {
+      "bytes": 462723,
+      "file": "source_split=early/phase=opening/positions.parquet",
+      "max_id": 2000000,
+      "min_id": 1900001,
+      "phase": "opening",
+      "row_groups": 1,
+      "rows": 15000,
+      "sha256": "5e7177ca9393325b169ac40cb8768f7510d6c7c52b44e9b1eaed4c12ef2dc9f5",
+      "source_split": "early"
+    },
+    {
+      "bytes": 2006400,
+      "file": "source_split=early/phase=middlegame/positions.parquet",
+      "max_id": 1995097,
+      "min_id": 1900004,
+      "phase": "middlegame",
+      "row_groups": 1,
+      "rows": 60000,
+      "sha256": "b7047c2783dccb7134ddac56b77688503d40d03ea396527f071928b7657bb7fb",
+      "source_split": "early"
+    },
+    {
+      "bytes": 752875,
+      "file": "source_split=early/phase=endgame/positions.parquet",
+      "max_id": 1998571,
+      "min_id": 1900047,
+      "phase": "endgame",
+      "row_groups": 1,
+      "rows": 25000,
+      "sha256": "572e45aa624e02ff34249fef5b238d3683df0b3d561ede4a809e80ad3ae801aa",
+      "source_split": "early"
+    },
+    {
+      "bytes": 1210334,
+      "file": "source_split=low/phase=opening/positions.parquet",
+      "max_id": 1892253,
+      "min_id": 1640020,
+      "phase": "opening",
+      "row_groups": 1,
+      "rows": 39000,
+      "sha256": "e24d3b998a74e5462046500276220dcdc72650984459657689bfc479b165d4d9",
+      "source_split": "low"
+    },
+    {
+      "bytes": 5130153,
+      "file": "source_split=low/phase=middlegame/positions.parquet",
+      "max_id": 1892012,
+      "min_id": 1640001,
+      "phase": "middlegame",
+      "row_groups": 3,
+      "rows": 156000,
+      "sha256": "babc921f7663d44feda792638a0fb1160af2e30963c7cd8db3dd965b9456cda0",
+      "source_split": "low"
+    },
+    {
+      "bytes": 1947198,
+      "file": "source_split=low/phase=endgame/positions.parquet",
+      "max_id": 1900000,
+      "min_id": 1640008,
+      "phase": "endgame",
+      "row_groups": 1,
+      "rows": 65000,
+      "sha256": "facf4685b2e1f922ebc5b9883ae9aa4f9c00bdfd46624022e2a505f475603ac1",
+      "source_split": "low"
+    },
+    {
+      "bytes": 2016352,
+      "file": "source_split=mid/phase=opening/positions.parquet",
+      "max_id": 1636511,
+      "min_id": 1200001,
+      "phase": "opening",
+      "row_groups": 2,
+      "rows": 66000,
+      "sha256": "bba32010584312b19fc5b7af297a1912c4a2bc0ed9329a8c964b67f951292177",
+      "source_split": "mid"
+    },
+    {
+      "bytes": 8540107,
+      "file": "source_split=mid/phase=middlegame/positions.parquet",
+      "max_id": 1621308,
+      "min_id": 1200003,
+      "phase": "middlegame",
+      "row_groups": 5,
+      "rows": 264001,
+      "sha256": "655819eb658ee1f384a7c403a930a824af875cde234024762e06d5db2027af93",
+      "source_split": "mid"
+    },
+    {
+      "bytes": 3316916,
+      "file": "source_split=mid/phase=endgame/positions.parquet",
+      "max_id": 1640000,
+      "min_id": 1200025,
+      "phase": "endgame",
+      "row_groups": 2,
+      "rows": 109999,
+      "sha256": "7134f22a7fefa7b20ac16dacd459ec1f184f42b3779cb2fe091e032f822984e5",
+      "source_split": "mid"
+    },
+    {
+      "bytes": 5418356,
+      "file": "source_split=strong/phase=opening/positions.parquet",
+      "max_id": 1198682,
+      "min_id": 1,
+      "phase": "opening",
+      "row_groups": 3,
+      "rows": 180000,
+      "sha256": "27b6176179db7b2389a264834d42b81088b55fcea01507fdf47e44dbd3b6e91f",
+      "source_split": "strong"
+    },
+    {
+      "bytes": 23599709,
+      "file": "source_split=strong/phase=middlegame/positions.parquet",
+      "max_id": 1156985,
+      "min_id": 3,
+      "phase": "middlegame",
+      "row_groups": 11,
+      "rows": 720000,
+      "sha256": "65f27ac62d7aece6f475df584319542664602ec901041474bf4a9fd67c56ffa2",
+      "source_split": "strong"
+    },
+    {
+      "bytes": 9033051,
+      "file": "source_split=strong/phase=endgame/positions.parquet",
+      "max_id": 1200000,
+      "min_id": 10,
+      "phase": "endgame",
+      "row_groups": 5,
+      "rows": 300000,
+      "sha256": "a65684ee64f5824dc03d396bb3a92786fd35ae2a7fda6b06cb96733202efc11e",
+      "source_split": "strong"
+    }
+  ],
+  "row_group_size": 65536,
+  "rows": 2000000,
+  "source": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/data/lc0-selfplay-2m.vpd",
+  "source_sha256": "0cbab31284e50c75d6cdef6de7d4656e77c6ab4a3a4fb848ecf110e5a8eeb7cc"
+}

lc0-selfplay-2m/source_split=early/phase=endgame/positions.parquet

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

lc0-selfplay-2m/source_split=early/phase=middlegame/positions.parquet

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

lc0-selfplay-2m/source_split=early/phase=opening/positions.parquet

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

lc0-selfplay-2m/source_split=low/phase=endgame/positions.parquet

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

lc0-selfplay-2m/source_split=low/phase=middlegame/positions.parquet

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

lc0-selfplay-2m/source_split=low/phase=opening/positions.parquet

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

lc0-selfplay-2m/source_split=mid/phase=endgame/positions.parquet

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

lc0-selfplay-2m/source_split=mid/phase=middlegame/positions.parquet

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

lc0-selfplay-2m/source_split=mid/phase=opening/positions.parquet

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

lc0-selfplay-2m/source_split=strong/phase=endgame/positions.parquet

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

lc0-selfplay-2m/source_split=strong/phase=middlegame/positions.parquet

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

lc0-selfplay-2m/source_split=strong/phase=opening/positions.parquet

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

lichess-elite-300k-variance.json

@@ -0,0 +1,90 @@
+{
+  "database": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/data/lichess-elite-300k.vpd",
+  "database_bytes": 88457216,
+  "distributions": {
+    "in_check": 21620,
+    "material_imbalance_abs_ge_3": 55336,
+    "phase": {
+      "endgame": 75000,
+      "middlegame": 180000,
+      "opening": 45000
+    },
+    "result": {
+      "*": 3,
+      "0-1": 125395,
+      "1-0": 137641,
+      "1/2-1/2": 36961
+    },
+    "side_to_move": {
+      "black": 150799,
+      "white": 149201
+    },
+    "source_split": {
+      "human": 300000
+    },
+    "with_castling_rights": 69526,
+    "without_castling_rights": 230474
+  },
+  "format": "VPD1",
+  "high_variance": false,
+  "metadata": {
+    "completed_unix": "1787662083",
+    "corpus": "lichess-elite-human",
+    "excluded_speeds": "ultrabullet,bullet",
+    "fen_fullmove_normalization": "1",
+    "format": "VPD1",
+    "months": "[\"2020-06\", \"2020-10\", \"2021-02\", \"2021-10\", \"2022-02\", \"2022-06\", \"2023-02\", \"2023-06\", \"2023-10\", \"2024-06\", \"2025-02\", \"2025-10\"]",
+    "months_done": "[\"2020-06\", \"2020-10\", \"2021-02\", \"2021-10\", \"2022-02\", \"2022-06\", \"2023-02\", \"2023-06\", \"2023-10\", \"2024-06\", \"2025-02\", \"2025-10\"]",
+    "per_game": "3",
+    "position_count": "300000",
+    "seed": "91",
+    "source": "https://database.nikonoel.fr/",
+    "speed_mix": "{\"2020-06\": {\"blitz\": 419793, \"bullet\": 614, \"classical\": 235, \"rapid\": 4156, \"ultrabullet\": 134}, \"2020-10\": {\"blitz\": 394174, \"bullet\": 985, \"classical\": 123, \"rapid\": 7759, \"ultrabullet\": 30}, \"2021-02\": {\"blitz\": 482896, \"bullet\": 765, \"classical\": 230, \"rapid\": 22605, \"ultrabullet\": 146}, \"2021-10\": {\"blitz\": 958088, \"bullet\": 1088, \"classical\": 268, \"rapid\": 66809, \"ultrabullet\": 111}, \"2022-02\": {\"blitz\": 358362, \"bullet\": 261, \"classical\": 42, \"rapid\": 15909, \"ultrabullet\": 66}, \"2022-06\": {\"blitz\": 317872, \"bullet\": 304, \"classical\": 149, \"rapid\": 16842, \"ultrabullet\": 64}, \"2023-02\": {\"blitz\": 251068, \"classical\": 438, \"rapid\": 16001}, \"2023-06\": {\"blitz\": 269958, \"classical\": 266, \"rapid\": 20810}, \"2023-10\": {\"blitz\": 263539, \"classical\": 1913, \"rapid\": 20468}, \"2024-06\": {\"blitz\": 237026, \"bullet\": 781, \"classical\": 836, \"rapid\": 14602, \"ultrabullet\": 76}, \"2025-02\": {\"blitz\": 240625, \"bullet\": 1204, \"classical\": 905, \"rapid\": 13639, \"ultrabullet\": 57}, \"2025-10\": {\"blitz\": 262599, \"bullet\": 1641, \"classical\": 1332, \"rapid\": 15244, \"ultrabullet\": 303}}",
+    "target_positions": "300000"
+  },
+  "normalized_phase_entropy": 0.853474,
+  "numeric": {
+    "legal_moves": {
+      "max": 94,
+      "mean": 30.3457,
+      "median": 33,
+      "min": 0,
+      "p10": 11,
+      "p90": 44,
+      "stdev": 12.1602
+    },
+    "material_balance_white_minus_black": {
+      "max": 52,
+      "mean": 0.017,
+      "median": 0,
+      "min": -67,
+      "p10": -2,
+      "p90": 2,
+      "stdev": 2.6994
+    },
+    "piece_count": {
+      "max": 32,
+      "mean": 21.785,
+      "median": 23,
+      "min": 2,
+      "p10": 11,
+      "p90": 30,
+      "stdev": 7.2753
+    }
+  },
+  "positions": 300000,
+  "thresholds": {
+    "at_least_1_5m_positions": false,
+    "both_castling_states_at_least_10pct": true,
+    "checks_at_least_1pct": true,
+    "legal_move_p10_at_most_22": true,
+    "legal_move_p90_at_least_38": true,
+    "legal_move_stdev_at_least_8": true,
+    "material_imbalance_at_least_15pct": true,
+    "phase_entropy_at_least_0_85": true,
+    "phase_min_share_at_least_15pct": true,
+    "piece_count_stdev_at_least_5": true,
+    "result_min_share_at_least_20pct": false,
+    "side_to_move_between_47_and_53pct_white": true
+  }
+}

lichess-elite-300k/_manifest.json

@@ -0,0 +1,49 @@
+{
+  "compression": "zstd",
+  "compression_level": 6,
+  "elapsed_seconds": 0.794,
+  "format": "VPD1-Parquet",
+  "partitioning": [
+    "source_split",
+    "phase"
+  ],
+  "partitions": [
+    {
+      "bytes": 1362411,
+      "file": "source_split=human/phase=opening/positions.parquet",
+      "max_id": 289784,
+      "min_id": 1,
+      "phase": "opening",
+      "row_groups": 1,
+      "rows": 45000,
+      "sha256": "5ff78f6b35751f46d98a387a7336a2e6aef953e3b2bdbd193bc6bdc07286becc",
+      "source_split": "human"
+    },
+    {
+      "bytes": 6763819,
+      "file": "source_split=human/phase=middlegame/positions.parquet",
+      "max_id": 300000,
+      "min_id": 2,
+      "phase": "middlegame",
+      "row_groups": 3,
+      "rows": 180000,
+      "sha256": "c470e9a3126c03a8af0001dbb567e6da9aae52c11a75439563f309404bb3cd82",
+      "source_split": "human"
+    },
+    {
+      "bytes": 2466867,
+      "file": "source_split=human/phase=endgame/positions.parquet",
+      "max_id": 295912,
+      "min_id": 3,
+      "phase": "endgame",
+      "row_groups": 2,
+      "rows": 75000,
+      "sha256": "f6f821171a524c53412c592e2546f6d8d9eb6dc4259b401246f0b5f7ac7311f7",
+      "source_split": "human"
+    }
+  ],
+  "row_group_size": 65536,
+  "rows": 300000,
+  "source": "/Users/pawit/Documents/vexilon/tmp/vex-position-dataset/data/lichess-elite-300k.vpd",
+  "source_sha256": "87c00d3e4b3c9387b7f71097f2b1826e6ad6c994ae8df24f267de400814e27f9"
+}

lichess-elite-300k/source_split=human/phase=endgame/positions.parquet

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

lichess-elite-300k/source_split=human/phase=middlegame/positions.parquet

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

lichess-elite-300k/source_split=human/phase=opening/positions.parquet

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

scripts/build_human_corpus.py

@@ -0,0 +1,299 @@
+"""Build the human partition of the corpus from the Lichess Elite Database.
+
+The Elite Database is the Lichess standard database filtered to games where a
+2400+ player faced a 2200+ player. It is published as one zip per month at
+database.nikonoel.fr.
+
+Composition, measured on 2025-08: about 88% of games are 3+0 or 3+2 blitz, 6%
+rapid, under 1% classical, with White Elo median 2550 and a maximum of 3215.
+The partition is therefore strong human blitz, not considered classical play.
+That is a real characteristic rather than a defect for this corpus: the point of
+a human partition is positions engines do not reach, and human blitz reaches
+plenty. It is recorded in the database metadata so it is never a surprise.
+Games below --min-base-seconds are dropped, which removes bullet.
+
+Sampling is two-phase per month. chess.pgn.read_headers skips move text and runs
+at about 75,000 games/s, against 1,300 for a full parse, so the whole month is
+indexed by byte offset first and only the games actually selected are parsed.
+That keeps selection uniform over games — sampling by byte offset instead would
+have favoured long games — while costing seconds rather than minutes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import hashlib
+import json
+import random
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+
+import chess
+import chess.pgn
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "vex-position-dataset"))
+from vpd import (  # noqa: E402
+    PHASE_NAMES,
+    connect,
+    initialize,
+    make_quotas,
+    phase_of,
+    position_record,
+    set_metadata,
+)
+
+from build_selfplay_corpus import INSERT_SQL, spread  # noqa: E402
+
+BASE = "https://database.nikonoel.fr"
+MONTH = re.compile(r"lichess_elite_(\d{4}-\d{2})\.zip")
+
+
+def list_months() -> list[str]:
+    out = subprocess.run(
+        ["curl", "-sS", "--max-time", "120", f"{BASE}/"], capture_output=True, text=True
+    )
+    return sorted(set(MONTH.findall(out.stdout)))
+
+
+SPEEDS = ("ultrabullet", "bullet", "blitz", "rapid", "classical", "correspondence")
+
+
+def base_seconds(time_control: str) -> int:
+    """Seconds on the clock before increment; 0 when unparseable."""
+
+    head = (time_control or "").split("+")[0]
+    return int(head) if head.isdigit() else 0
+
+
+def speed_category(headers) -> str:
+    """Classify a game's speed from whichever headers the month provides.
+
+    The Elite Database changed schema partway through its history. Months from
+    2025 carry TimeControl, LichessURL and UTCDate; older months instead carry
+    EventType and PlyCount and no TimeControl at all. Reading only TimeControl
+    silently rejects every game in the older format, so all three sources are
+    tried and anything still unrecognised is kept rather than dropped.
+    """
+
+    base = base_seconds(headers.get("TimeControl", ""))
+    if base:
+        if base < 60:
+            return "ultrabullet"
+        if base < 180:
+            return "bullet"
+        if base < 480:
+            return "blitz"
+        if base < 1500:
+            return "rapid"
+        return "classical"
+    event_type = headers.get("EventType", "").strip().lower()
+    if event_type in SPEEDS:
+        return event_type
+    event = headers.get("Event", "").lower()
+    for name in SPEEDS:
+        if name in event:
+            return name
+    return "unknown"
+
+
+def index_month(pgn: Path, excluded: frozenset[str]) -> tuple[list[int], collections.Counter]:
+    """Byte offsets of every eligible game, plus the speed mix."""
+
+    offsets: list[int] = []
+    mix: collections.Counter = collections.Counter()
+    # utf-8-sig: some months begin with a byte order mark.
+    with open(pgn, encoding="utf-8-sig", errors="replace") as handle:
+        while True:
+            offset = handle.tell()
+            headers = chess.pgn.read_headers(handle)
+            if headers is None:
+                break
+            speed = speed_category(headers)
+            mix[speed] += 1
+            if speed not in excluded:
+                offsets.append(offset)
+    return offsets, mix
+
+
+def sample_positions(
+    game: chess.pgn.Game,
+    per_game: int,
+    counts: dict[int, int],
+    phase_quotas: dict[int, int],
+    rng: random.Random,
+) -> list[tuple[chess.Board, int, int, str]]:
+    """Reservoir one position per phase, as the CCRL extractor does."""
+
+    board = game.board()
+    reservoir: dict[int, tuple[chess.Board, int]] = {}
+    seen = {phase: 0 for phase in PHASE_NAMES}
+    try:
+        for ply, move in enumerate(game.mainline_moves(), start=1):
+            board.push(move)
+            phase = phase_of(board, ply)
+            if counts[phase] >= phase_quotas[phase]:
+                continue
+            seen[phase] += 1
+            if rng.randrange(seen[phase]) == 0:
+                reservoir[phase] = (board.copy(stack=False), ply)
+    except (ValueError, AssertionError):
+        return []
+
+    result = game.headers.get("Result", "*")
+    picks = [(b, phase, ply, result) for phase, (b, ply) in reservoir.items()]
+    rng.shuffle(picks)
+    return picks[:per_game]
+
+
+def process_month(
+    db, month: str, counts: dict[int, int], phase_quotas: dict[int, int],
+    quota: int, per_game: int, excluded: frozenset[str], seed: int, scratch: Path,
+) -> dict[str, object]:
+    stats: dict[str, object] = {"games": 0, "inserted": 0, "eligible": 0, "mix": {}}
+    workdir = Path(tempfile.mkdtemp(prefix="elite.", dir=scratch))
+    try:
+        archive = workdir / f"{month}.zip"
+        subprocess.run(
+            ["curl", "-fsS", "--max-time", "1800", f"{BASE}/lichess_elite_{month}.zip",
+             "-o", str(archive)],
+            capture_output=True,
+        )
+        if not archive.exists() or archive.stat().st_size < 1_000_000:
+            return stats
+        with zipfile.ZipFile(archive) as zf:
+            name = zf.namelist()[0]
+            pgn = workdir / name
+            with zf.open(name) as src, open(pgn, "wb") as dst:
+                shutil.copyfileobj(src, dst, 1 << 20)
+        archive.unlink()
+
+        offsets, mix = index_month(pgn, excluded)
+        stats["eligible"] = len(offsets)
+        stats["mix"] = dict(mix.most_common())
+        if not offsets:
+            return stats
+
+        rng = random.Random(
+            int.from_bytes(
+                hashlib.blake2b(f"{seed}:{month}".encode(), digest_size=8).digest(), "big"
+            )
+        )
+        rng.shuffle(offsets)
+
+        with open(pgn, encoding="utf-8-sig", errors="replace") as handle:
+            for offset in offsets:
+                if sum(counts.values()) >= quota:
+                    break
+                handle.seek(offset)
+                game = chess.pgn.read_game(handle)
+                if game is None:
+                    continue
+                stats["games"] += 1
+                picks = sample_positions(game, per_game, counts, phase_quotas, rng)
+                for board, phase, ply, result in picks:
+                    cursor = db.execute(
+                        INSERT_SQL,
+                        position_record(
+                            board, "human", f"lichess-elite/{month}",
+                            stats["games"], ply, result, phase,
+                        ),
+                    )
+                    if cursor.rowcount:
+                        counts[phase] += 1
+                        stats["inserted"] = int(stats["inserted"]) + 1
+    finally:
+        shutil.rmtree(workdir, ignore_errors=True)
+    return stats
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--target", type=int, default=300_000)
+    parser.add_argument("--per-game", type=int, default=3)
+    parser.add_argument("--months", type=int, default=12)
+    parser.add_argument("--exclude-speeds", default="ultrabullet,bullet",
+                        help="comma-separated speeds to drop; empty keeps everything")
+    parser.add_argument("--seed", type=int, default=91)
+    parser.add_argument("--scratch", type=Path, default=Path(tempfile.gettempdir()))
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    excluded = frozenset(x.strip() for x in args.exclude_speeds.split(",") if x.strip())
+    available = list_months()
+    if not available:
+        sys.exit("Could not list months from database.nikonoel.fr")
+    chosen = sorted(available[i] for i in spread(len(available))[: args.months])
+    print(f"{len(available)} months available ({available[0]} .. {available[-1]})")
+    print(f"Using {len(chosen)}: {', '.join(chosen)}")
+    print(f"Target {args.target:,} positions, {args.per_game} per game, "
+          f"excluding {sorted(excluded) or ['nothing']}")
+    if args.dry_run:
+        return
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    db = connect(args.output)
+    initialize(db)
+    set_metadata(db, "corpus", "lichess-elite-human")
+    set_metadata(db, "source", f"{BASE}/")
+    set_metadata(db, "target_positions", args.target)
+    set_metadata(db, "seed", args.seed)
+    set_metadata(db, "per_game", args.per_game)
+    set_metadata(db, "excluded_speeds", args.exclude_speeds)
+    set_metadata(db, "months", json.dumps(chosen))
+    db.commit()
+
+    counts = {
+        p: db.execute("SELECT COUNT(*) FROM positions WHERE phase=?", (p,)).fetchone()[0]
+        for p in PHASE_NAMES
+    }
+    done_row = db.execute("SELECT value FROM metadata WHERE key='months_done'").fetchone()
+    months_done = set(json.loads(done_row[0])) if done_row else set()
+    mixes: dict[str, dict] = {}
+    started = time.monotonic()
+
+    # Each month gets an equal share, otherwise the first month alone fills the
+    # target and the spread across the database's history never happens.
+    for index, month in enumerate(chosen, start=1):
+        if sum(counts.values()) >= args.target or month in months_done:
+            continue
+        cumulative = min(args.target, round(args.target * index / len(chosen)))
+        stats = process_month(
+            db, month, counts, make_quotas(cumulative), cumulative, args.per_game,
+            excluded, args.seed, args.scratch,
+        )
+        mixes[month] = stats["mix"]
+        months_done.add(month)
+        set_metadata(db, "months_done", json.dumps(sorted(months_done)))
+        set_metadata(db, "speed_mix", json.dumps(mixes, sort_keys=True))
+        db.commit()
+        print(
+            f"  {month}  eligible={stats['eligible']:>7,}  read={stats['games']:>7,}  "
+            f"+{stats['inserted']:>6,} -> {sum(counts.values()):,}/{args.target:,}  "
+            f"[{(time.monotonic() - started) / 60:.1f}m]",
+            flush=True,
+        )
+
+    total = db.execute("SELECT COUNT(*) FROM positions").fetchone()[0]
+    set_metadata(db, "position_count", total)
+    set_metadata(db, "completed_unix", int(time.time()))
+    db.commit()
+    print(f"\nWrote {total:,} positions to {args.output}")
+    for phase, count in db.execute(
+        "SELECT phase, COUNT(*) FROM positions GROUP BY phase ORDER BY phase"
+    ):
+        print(f"  {PHASE_NAMES[phase]:11} {count:>8,}")
+    db.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/build_selfplay_corpus.py

@@ -0,0 +1,422 @@
+"""Build a tiered lc0 self-play position corpus as a VPD1 database.
+
+For every run slice named in lc0_runs.TIERS this streams a bounded prefix of
+several tars, converts them to FENs through the rescorer, samples a few
+positions per game, and inserts them into the same VPD1 schema the CCRL corpus
+uses, so the two are directly comparable.
+
+Two choices are worth stating.
+
+Tars are read as bounded prefixes rather than in full. Positions cost the same
+number of bytes either way, but a prefix of each of forty tars spans forty
+points in a run's history, where four whole tars span four. Network diversity
+per byte downloaded is much better, and it is the diversity that this corpus is
+for.
+
+Only a few positions per game are kept. A game contributes about 110 positions,
+and consecutive ones are near-duplicates; sampling across phases keeps the
+effective sample size close to the row count. The CCRL corpus took three per
+game. Eight is the default here because these tars must be downloaded rather
+than read from a local archive, and eight cuts the download roughly fourfold
+for positions that are still tens of plies apart.
+
+Nothing is dropped for being hard to train on. Chess960 positions are dropped
+by default only because their Shredder-FEN castling fields are not standard
+chess and the rest of this pipeline assumes standard chess; pass
+--keep-chess960 to retain them.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+import chess
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "vex-position-dataset"))
+from vpd import (  # noqa: E402
+    PHASE_NAMES,
+    connect,
+    current_counts,
+    initialize,
+    make_quotas,
+    phase_of,
+    position_record,
+    set_metadata,
+)
+
+from lc0_runs import EXCLUDED, TIERS, quotas, run_quotas  # noqa: E402
+
+BASE = "https://storage.lczero.org/files/training_data"
+LISTING_ROW = re.compile(r'href="([^"]+\.tar)">[^<]*</a>\s+(\S+)\s+(\S+)\s+(\d+)')
+STANDARD_CASTLING = set("KQkq-")
+MIN_REAL_TAR = 50_000_000
+
+INSERT_SQL = """
+    INSERT OR IGNORE INTO positions(
+      random_key, fen, source_split, source_member, game_number, ply,
+      result, side_to_move, phase, piece_count, non_pawn_material,
+      material_balance, legal_moves, in_check, castling_mask, halfmove_clock
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+"""
+
+
+def spread(count: int) -> list[int]:
+    """Indices 0..count-1 ordered so that any prefix is spread over the range.
+
+    Van der Corput: reversing the bits of successive integers visits the range
+    at ever finer resolution, so stopping early still leaves the tars taken
+    scattered across the run's history rather than clustered at one end.
+    """
+
+    if count <= 0:
+        return []
+    bits = max(1, (count - 1).bit_length())
+    seen: list[int] = []
+    used = set()
+    for i in range(1 << bits):
+        reversed_bits = int(format(i, f"0{bits}b")[::-1], 2)
+        if reversed_bits < count and reversed_bits not in used:
+            used.add(reversed_bits)
+            seen.append(reversed_bits)
+    return seen
+
+
+def list_tars(run: str, cache: dict[str, list[tuple[str, int]]]) -> list[tuple[str, int]]:
+    if run in cache:
+        return cache[run]
+    out = subprocess.run(
+        ["curl", "-sS", "--max-time", "180", f"{BASE}/{run}/"],
+        capture_output=True,
+        text=True,
+    )
+    rows = [
+        (name, int(size))
+        for name, _, _, size in LISTING_ROW.findall(out.stdout)
+        if int(size) >= MIN_REAL_TAR
+    ]
+    cache[run] = rows
+    return rows
+
+
+def fetch_prefix(run: str, tar: str, limit: int, destination: Path) -> int:
+    """Download at most `limit` bytes of a tar.
+
+    head closes the socket once it has enough, which the CDN honours where it
+    ignores Range requests.
+    """
+
+    command = (
+        f'curl -sS --max-time 900 "{BASE}/{run}/{tar}" | head -c {limit} > "{destination}"'
+    )
+    subprocess.run(command, shell=True, capture_output=True)
+    return destination.stat().st_size if destination.exists() else 0
+
+
+def to_plain(rescorer: Path, tar_path: Path, workdir: Path, threads: int) -> Path | None:
+    subprocess.run(["tar", "xf", str(tar_path), "-C", str(workdir)], capture_output=True)
+    chunks = list(workdir.rglob("*.gz"))
+    if not chunks:
+        return None
+    plain = workdir / "positions.plain"
+    subprocess.run(
+        [
+            str(rescorer),
+            "rescore",
+            f"--input={chunks[0].parent}",
+            "--no-delete-files",
+            f"--nnue-plain-file={plain}",
+            "--nnue-best-score=true",
+            "--nnue-best-move=true",
+            "--deblunder=false",
+            f"--threads={threads}",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    return plain if plain.exists() else None
+
+
+def games(plain: Path):
+    """Yield (fen, ply, result) lists, one per game.
+
+    The rescorer appends games back to back and restarts ply at zero for each,
+    so a non-increasing ply is a game boundary.
+    """
+
+    current: list[tuple[str, int, str]] = []
+    fen = None
+    ply = None
+    last_ply = None
+    with open(plain, encoding="utf-8", errors="replace") as handle:
+        for row in handle:
+            if row.startswith("fen "):
+                fen = row[4:].strip()
+            elif row.startswith("ply "):
+                ply = int(row[4:])
+            elif row.startswith("result "):
+                result = row[7:].strip()
+            elif row.startswith("e") and row.strip() == "e":
+                if fen is None or ply is None:
+                    continue
+                if last_ply is not None and ply <= last_ply and current:
+                    yield current
+                    current = []
+                current.append((fen, ply, result))
+                last_ply = ply
+                fen = ply = None
+    if current:
+        yield current
+
+
+def absolute_result(plain_result: str, white_to_move: bool) -> str:
+    """Convert a .plain result to the PGN string VPD1 stores.
+
+    Stockfish's plain format reports the game outcome from the side to move's
+    perspective as 1/0/-1. VPD1 stores an absolute PGN result, as the CCRL
+    corpus does, so the two are comparable and vpd.py analyze can read them.
+    """
+
+    try:
+        value = int(plain_result)
+    except (TypeError, ValueError):
+        return "*"
+    if value == 0:
+        return "1/2-1/2"
+    white_won = (value > 0) == white_to_move
+    return "1-0" if white_won else "0-1"
+
+
+def sample_game(
+    positions: list[tuple[str, int, str]],
+    per_game: int,
+    counts: dict[int, int],
+    phase_quotas: dict[int, int],
+    rng: random.Random,
+    keep_chess960: bool,
+) -> list[tuple[chess.Board, int, int, str]]:
+    """Pick a spread of positions from one game, respecting phase quotas."""
+
+    by_phase: dict[int, list[tuple[chess.Board, int, str]]] = {p: [] for p in PHASE_NAMES}
+    for fen, ply, result in positions:
+        if not keep_chess960 and not set(fen.split(" ")[2]) <= STANDARD_CASTLING:
+            continue
+        try:
+            board = chess.Board(fen)
+        except ValueError:
+            continue
+        by_phase[phase_of(board, ply)].append((board, ply, result))
+
+    # Split the per-game budget in the same 15/60/25 proportion as the corpus
+    # quota. Taking an equal count from each phase instead saturates the small
+    # opening quota long before the others, after which most of a downloaded
+    # game is discarded.
+    total_quota = sum(phase_quotas.values()) or 1
+    chosen: list[tuple[chess.Board, int, int, str]] = []
+    for phase, available in by_phase.items():
+        if not available or counts[phase] >= phase_quotas[phase]:
+            continue
+        wanted = max(1, round(per_game * phase_quotas[phase] / total_quota))
+        take = min(wanted, len(available), phase_quotas[phase] - counts[phase])
+        for board, ply, result in rng.sample(available, take):
+            chosen.append((board, phase, ply, result))
+    return chosen
+
+
+def process_tar(
+    db,
+    rescorer: Path,
+    run: str,
+    tar: str,
+    tier: str,
+    limit: int,
+    threads: int,
+    per_game: int,
+    counts: dict[int, int],
+    phase_quotas: dict[int, int],
+    seed: int,
+    keep_chess960: bool,
+    scratch: Path,
+) -> dict[str, int]:
+    stats = {"bytes": 0, "games": 0, "inserted": 0, "chess960": 0}
+    workdir = Path(tempfile.mkdtemp(prefix="lc0tar.", dir=scratch))
+    try:
+        tar_path = workdir / "prefix.tar"
+        stats["bytes"] = fetch_prefix(run, tar, limit, tar_path)
+        if stats["bytes"] < 100_000:
+            return stats
+        plain = to_plain(rescorer, tar_path, workdir, threads)
+        if plain is None:
+            return stats
+        tar_path.unlink(missing_ok=True)
+
+        for game_number, positions in enumerate(games(plain), start=1):
+            stats["games"] += 1
+            stats["chess960"] += sum(
+                not set(f.split(" ")[2]) <= STANDARD_CASTLING for f, _, _ in positions
+            )
+            rng = random.Random(
+                int.from_bytes(
+                    hashlib.blake2b(
+                        f"{seed}:{tar}:{game_number}".encode(), digest_size=8
+                    ).digest(),
+                    "big",
+                )
+            )
+            for board, phase, ply, result in sample_game(
+                positions, per_game, counts, phase_quotas, rng, keep_chess960
+            ):
+                cursor = db.execute(
+                    INSERT_SQL,
+                    position_record(
+                        board, tier, f"{run}/{tar}", game_number, ply,
+                        absolute_result(result, board.turn == chess.WHITE), phase,
+                    ),
+                )
+                if cursor.rowcount:
+                    counts[phase] += 1
+                    stats["inserted"] += 1
+            if all(counts[p] >= phase_quotas[p] for p in phase_quotas):
+                break
+    finally:
+        shutil.rmtree(workdir, ignore_errors=True)
+    return stats
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--target", type=int, default=2_000_000)
+    parser.add_argument("--per-game", type=int, default=12)
+    parser.add_argument("--slice-bytes", type=int, default=120_000_000)
+    parser.add_argument("--threads", type=int, default=8)
+    parser.add_argument("--seed", type=int, default=91)
+    parser.add_argument("--keep-chess960", action="store_true")
+    parser.add_argument("--scratch", type=Path, default=Path(tempfile.gettempdir()))
+    parser.add_argument(
+        "--rescorer",
+        type=Path,
+        default=Path(__file__).resolve().parent.parent / "lc0-rescorer/build/release/rescorer",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="show the plan and exit")
+    args = parser.parse_args()
+
+    if not args.rescorer.exists():
+        sys.exit(f"No rescorer at {args.rescorer}")
+
+    tier_quota = quotas(args.target)
+    plan: list[tuple[str, str, float, float, int]] = []
+    for tier in TIERS:
+        for key, quota in run_quotas(tier, tier_quota[tier.name]).items():
+            name, window = key.split(":")
+            first, last = (float(x) for x in window.split("-"))
+            plan.append((tier.name, name, first, last, quota))
+
+    print("Excluded runs:")
+    for name, why in EXCLUDED.items():
+        print(f"  {name:9} {why}")
+    print(f"\nTarget {args.target:,} positions, {args.per_game} per game, "
+          f"{args.slice_bytes / 1e6:.0f} MB per tar\n")
+    for tier, run, first, last, quota in plan:
+        print(f"  {tier:7} {run:9} [{first:.2f}-{last:.2f}]  {quota:>9,}")
+    if args.dry_run:
+        return
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    db = connect(args.output)
+    initialize(db)
+    set_metadata(db, "corpus", "lc0-selfplay-tiered")
+    set_metadata(db, "source", BASE)
+    set_metadata(db, "target_positions", args.target)
+    set_metadata(db, "seed", args.seed)
+    set_metadata(db, "per_game", args.per_game)
+    set_metadata(db, "slice_bytes", args.slice_bytes)
+    set_metadata(db, "keep_chess960", int(args.keep_chess960))
+    set_metadata(db, "excluded_runs", json.dumps(EXCLUDED, sort_keys=True))
+    set_metadata(db, "tier_quotas", json.dumps(tier_quota, sort_keys=True))
+    db.commit()
+
+    done_row = db.execute("SELECT value FROM metadata WHERE key='tars_done'").fetchone()
+    tars_done = set(json.loads(done_row[0])) if done_row else set()
+
+    listing_cache: dict[str, list[tuple[str, int]]] = {}
+    started = time.monotonic()
+
+    for tier, run, first, last, quota in plan:
+        have = db.execute(
+            "SELECT COUNT(*) FROM positions WHERE source_split=? AND source_member LIKE ?",
+            (tier, f"{run}/%"),
+        ).fetchone()[0]
+        if have >= quota:
+            print(f"[{tier}/{run}] already at {have:,}/{quota:,}")
+            continue
+
+        tars = list_tars(run, listing_cache)
+        window = tars[int(len(tars) * first) : max(int(len(tars) * last), 1)]
+        if not window:
+            print(f"[{tier}/{run}] no tars in window", file=sys.stderr)
+            continue
+
+        # Phase quotas are scoped to this run slice so each contributes the same
+        # opening/middlegame/endgame mix as the CCRL corpus.
+        base = {
+            p: db.execute(
+                "SELECT COUNT(*) FROM positions WHERE source_split=? "
+                "AND source_member LIKE ? AND phase=?",
+                (tier, f"{run}/%", p),
+            ).fetchone()[0]
+            for p in PHASE_NAMES
+        }
+        slice_quota = make_quotas(quota)
+        counts = dict(base)
+
+        print(f"\n[{tier}/{run}] {have:,}/{quota:,} from {len(window)} tars "
+              f"in [{first:.2f}-{last:.2f}]")
+
+        for index in spread(len(window)):
+            if all(counts[p] >= slice_quota[p] for p in slice_quota):
+                break
+            tar = window[index][0]
+            token = f"{run}/{tar}"
+            if token in tars_done:
+                continue
+            stats = process_tar(
+                db, args.rescorer, run, tar, tier, args.slice_bytes, args.threads,
+                args.per_game, counts, slice_quota, args.seed, args.keep_chess960,
+                args.scratch,
+            )
+            tars_done.add(token)
+            set_metadata(db, "tars_done", json.dumps(sorted(tars_done)))
+            db.commit()
+            total = sum(counts.values())
+            elapsed = time.monotonic() - started
+            print(
+                f"  {tar[-21:]:21} {stats['bytes'] / 1e6:6.0f}MB "
+                f"games={stats['games']:5,} +{stats['inserted']:6,} "
+                f"-> {total:,}/{quota:,}  [{elapsed / 60:.1f}m]",
+                flush=True,
+            )
+
+    total = db.execute("SELECT COUNT(*) FROM positions").fetchone()[0]
+    set_metadata(db, "position_count", total)
+    set_metadata(db, "completed_unix", int(time.time()))
+    db.commit()
+    print(f"\nWrote {total:,} positions to {args.output}")
+    for row in db.execute(
+        "SELECT source_split, COUNT(*) FROM positions GROUP BY source_split ORDER BY 2 DESC"
+    ):
+        print(f"  {row[0]:8} {row[1]:>9,}")
+    db.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/lc0_runs.py

@@ -0,0 +1,102 @@
+"""Which lc0 self-play runs to draw from, and in what proportion.
+
+Tiers follow generation quality: the networks producing the games get weaker as
+you go down, so the lower tiers contribute noisier, more exploratory positions.
+Keeping a minority of them is deliberate — a corpus drawn only from the strongest
+run is narrow in exactly the way this corpus is meant not to be.
+
+Availability was surveyed against storage.lczero.org on 2026-08-25 and differs
+from the run list usually quoted:
+
+  * test70, test77, test76, test50, test20 and test10 are not hosted at all.
+  * test78 and test90 exist but every tar is a 10 KB placeholder.
+  * test80's retained window now starts 2024-04-01; earlier tars were pruned.
+  * test80 stopped producing on 2025-09-24. test91 is the live run.
+  * test71 is the Chess960 run — measured 30-36% Chess960 against at most 1.2%
+    elsewhere — so it is excluded rather than tiered. test71_5 measured 0%.
+
+Named substitutes for the missing runs stay in era and strength order:
+test79 and test75 stand in for T70/T78 in the mid tier, test71_5 for T50.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class Run:
+    name: str
+    # Restrict to a slice of the run's date-sorted tars, as "late test60" and
+    # "early test60" belong to different tiers.
+    first: float = 0.0
+    last: float = 1.0
+    weight: float = 1.0
+
+
+@dataclass(frozen=True)
+class Tier:
+    name: str
+    share: float
+    runs: tuple[Run, ...]
+    note: str = ""
+
+
+TIERS: tuple[Tier, ...] = (
+    Tier(
+        "strong",
+        0.60,
+        (Run("test80", weight=2.0), Run("test91", weight=1.0)),
+        "Mature run1 plus the live run2. Core modern play.",
+    ),
+    Tier(
+        "mid",
+        0.22,
+        (Run("test79"), Run("test75"), Run("test60", first=0.60)),
+        "Late-T60 through T79: transitional styles, sound but more varied.",
+    ),
+    Tier(
+        "low",
+        0.13,
+        (Run("test40"), Run("test60", last=0.35), Run("test71_5", weight=0.5)),
+        "2019-2020 nets. Messier tactics and unusual structures.",
+    ),
+    Tier(
+        "early",
+        0.05,
+        (Run("test30"), Run("run3", weight=0.5)),
+        "2018-2019 semi-initial play. Kept small; maximum noise.",
+    ),
+)
+
+EXCLUDED = {
+    "test71": "Chess960 run; 30-36% of positions are Chess960",
+    "test78": "all tars are 10 KB placeholders",
+    "test90": "all tars are 10 KB placeholders",
+}
+
+
+def quotas(total: int) -> dict[str, int]:
+    """Positions per tier, with the rounding residue given to the largest."""
+
+    assigned = {tier.name: int(total * tier.share) for tier in TIERS}
+    largest = max(TIERS, key=lambda t: t.share).name
+    assigned[largest] += total - sum(assigned.values())
+    return assigned
+
+
+def run_quotas(tier: Tier, tier_total: int) -> dict[str, int]:
+    """Positions per (run, slice) inside one tier, split by run weight."""
+
+    total_weight = sum(r.weight for r in tier.runs)
+    out: dict[str, int] = {}
+    for run in tier.runs:
+        key = f"{run.name}:{run.first:.2f}-{run.last:.2f}"
+        out[key] = int(tier_total * run.weight / total_weight)
+    residue = tier_total - sum(out.values())
+    if out:
+        out[next(iter(out))] += residue
+    return out
+
+
+assert abs(sum(t.share for t in TIERS) - 1.0) < 1e-9

scripts/plain_to_fen.py

@@ -0,0 +1,81 @@
+"""Extract every FEN from a Stockfish .plain file.
+
+This replaces filter_plain.py for consumers that want positions rather than
+Stockfish NNUE training samples. filter_plain.py drops any position holding
+castling rights that did not arise from a standard opening, because Stockfish
+cannot train on Chess960 castling. Nothing here is dropped by default: the
+positions are the product, and which ones to keep is the caller's decision.
+
+Chess960 positions are recognised and counted, and can be excluded with
+--standard-only. They are reported either way, so the composition of the output
+is never silent.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import sys
+from pathlib import Path
+
+# Shredder-FEN castling fields name the rook files, so anything outside KQkq is
+# a Chess960 game. lc0's test80 run mixes a small share of them into self-play.
+STANDARD_CASTLING = set("KQkq-")
+
+
+def is_chess960(fen: str) -> bool:
+    field = fen.split(" ")[2]
+    return not set(field) <= STANDARD_CASTLING
+
+
+def opened(path: Path, mode: str):
+    if path.suffix == ".gz":
+        return gzip.open(path, mode + "t", encoding="utf-8")
+    return open(path, mode, encoding="utf-8")
+
+
+def convert(source: Path, destination: Path, standard_only: bool) -> dict[str, int]:
+    counts = {"positions": 0, "chess960": 0, "written": 0}
+    with opened(source, "r") as infile, opened(destination, "w") as outfile:
+        for row in infile:
+            if not row.startswith("fen "):
+                continue
+            fen = row[4:].strip()
+            counts["positions"] += 1
+            frc = is_chess960(fen)
+            counts["chess960"] += frc
+            if standard_only and frc:
+                continue
+            counts["written"] += 1
+            outfile.write(fen + "\n")
+    return counts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("input", type=Path, help="a .plain or .plain.gz file")
+    parser.add_argument("-o", "--output", type=Path)
+    parser.add_argument(
+        "--standard-only",
+        action="store_true",
+        help="drop Chess960 positions instead of keeping them",
+    )
+    args = parser.parse_args()
+
+    destination = args.output
+    if destination is None:
+        stem = args.input.name.replace(".plain.gz", "").replace(".plain", "")
+        destination = args.input.with_name(stem + ".fen")
+
+    counts = convert(args.input, destination, args.standard_only)
+    print(
+        f"{args.input} -> {destination}\n"
+        f"  positions read:    {counts['positions']:,}\n"
+        f"  chess960:          {counts['chess960']:,}\n"
+        f"  written:           {counts['written']:,}",
+        file=sys.stderr,
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/rescorer-optional-syzygy.patch

@@ -0,0 +1,25 @@
+diff --git a/src/selfplay/loop.cc b/src/selfplay/loop.cc
+index a0a03d7..6bc4736 100644
+--- a/src/selfplay/loop.cc
++++ b/src/selfplay/loop.cc
+@@ -905,7 +905,7 @@ void ProcessFile(const std::string& file, SyzygyTablebase* tablebase,
+           const auto& board = history.Last().GetBoard();
+           if (board.castlings().no_legal_castle() &&
+               (board.ours() | board.theirs()).count() <= 3 &&
+-              board.pawns().empty()) {
++              tablebase->max_cardinality() >= 3 && board.pawns().empty()) {
+             ProbeState state;
+             WDLScore wdl = tablebase->probe_wdl(history.Last(), &state);
+             // Only fail state means the WDL is wrong, probe_wdl may produce
+@@ -1239,8 +1239,9 @@ void RescoreLoop::RunLoop() {
+   if (!tablebase.init(
+           options_.GetOptionsDict().Get<std::string>(kSyzygyTablebaseId)) ||
+       tablebase.max_cardinality() < 3) {
+-    std::cerr << "FAILED TO LOAD SYZYGY" << std::endl;
+-    return;
++    std::cerr << "No Syzygy tablebases loaded; continuing without tablebase "
++                 "rescoring. Positions and moves are unaffected."
++              << std::endl;
+   }
+   auto dtmPaths =
+       options_.GetOptionsDict().Get<std::string>(kGaviotaTablebaseId);