Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+libraries/neg_test_library.csv filter=lfs diff=lfs merge=lfs -text
+libraries/neg_val_library.csv filter=lfs diff=lfs merge=lfs -text
+libraries/pos_test_library.csv filter=lfs diff=lfs merge=lfs -text
+libraries/pos_val_library.csv filter=lfs diff=lfs merge=lfs -text
+split_A_full_msnlib/row_formula_fold.csv filter=lfs diff=lfs merge=lfs -text

NOTICE.md

@@ -0,0 +1,93 @@
+# NOTICE — upstream attribution, provenance and licensing
+
+This package is a **derived benchmark manifest**, not a re-release of the MSnLib spectra.
+It contains compound identities (raw and RDKit canonical SMILES), molecular formulas,
+source-row pointers into `MSnLib.csv`, precursor m/z, adduct, collision energy and the
+train / validation / test assignments of two independent, frozen benchmark splits. The
+manifest itself contains no mass spectra (`mzs` / `intensities`).
+
+The Hugging Face dataset that mirrors this manifest additionally hosts two large source
+files, because every table points into them:
+
+| hosted file | bytes | SHA-256 | content |
+| --- | ---: | --- | --- |
+| `MSnLib.csv` | 752,707,651 | `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07` | one row per MSnLib spectrum (560,084 rows), including the `mzs` / `intensities` peak lists |
+| `MSnLib_candidates.json` | 1,368,264,026 | `125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc` | candidate SMILES lists behind the single-spectrum candidate-ranking task (JSON object: query SMILES → candidate SMILES list; 9,886 query entries) |
+
+Both hosted files derive from the MSnLib release and remain under **CC BY 4.0** with
+attribution to the MSnLib authors; the candidate lists are derived from the MSnLib compound
+set by UltraMS.
+
+## Upstream resource: MSnLib
+
+* Brungs C., Schmid R., Pluskal T. *MSnLib: efficient generation of open multi-stage
+  fragmentation mass spectral libraries.* Nature Methods (2025),
+  doi:[10.1038/s41592-025-02813-0](https://doi.org/10.1038/s41592-025-02813-0).
+* Data release: *MSnLib mass spectral libraries*,
+  Zenodo [10.5281/zenodo.11163380](https://doi.org/10.5281/zenodo.11163380) (2024).
+* License: **Creative Commons Attribution 4.0 International (CC BY 4.0)**.
+  Attribution to the MSnLib authors is required for any reuse of the material derived from
+  it, including the compound identities, formulas and metadata distributed here.
+
+The 18 MSnLib original per-file MS2 JSONL releases contain exactly **560,084 records**,
+equal to the number of data rows of the `MSnLib.csv` file this package indexes. `MSnLib.csv`
+is the UltraMS CSV conversion of those records (one row per spectrum; peaks stored as
+comma-separated strings; 752,707,651 bytes; SHA-256
+`be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07`). It is not part of this
+manifest; it is hosted with the Hugging Face mirror (see `README.md` §8.1).
+
+## Retention times
+
+`split_A_full_msnlib/msnlib_rt.csv.gz` contains the per-spectrum retention time
+(`row_index, rt` in seconds). RT is **source metadata from the MSnLib records** and remains
+under CC BY 4.0 with attribution to the MSnLib authors. The table was exported from
+`MSnLib_with_rt.csv` (755,984,910 bytes, SHA-256
+`a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964`) after verifying that
+its row order and first seven columns are identical to `MSnLib.csv` (560,084 rows, 0
+mismatches; see `split_A_full_msnlib/VERIFY.md` §5.4).
+
+## What UltraMS added (the original contribution of this package)
+
+* the CSV representation of the MSnLib release and the source-row pointers,
+* the frozen **formula-level split A** (all adducts: 21,107 formulas; 16,885 / 2,110 / 2,112
+  formulas and 446,667 / 55,980 / 57,437 spectra for train / validation / test),
+* the frozen **strict-adduct molecule-level split B** (70/15/15 by canonical isomeric
+  SMILES, per polarity, with frozen query and library definitions),
+* the query / library / voting tables, row metadata, protocol arrays, rebuild scripts and
+  verification artifacts derived from them.
+
+The split assignments themselves are an original creation of this work and may be reused
+with attribution. The compound identities and metadata derived from MSnLib remain under
+CC BY 4.0.
+
+## UltraMS code (rebuild scripts only)
+
+* Li Y., Zhong Y., Liu P., Xia J. *UltraMS.* Apache License 2.0
+  (repository: <https://github.com/Dsadd4/UltraMS>).
+* `rebuild/build_library_manifest.py` and `rebuild/baseline_common.py` are byte-identical
+  copies of files from the UltraMS public release
+  (`benchmarks/molecular_identification/source_code/original/`). Their license text is
+  reproduced in `rebuild/LICENSE-APACHE-2.0.txt`; the files keep their original copyright
+  and attribution.
+* `rebuild/verify_release.py` and `split_A_full_msnlib/build_split_a.py` are original
+  verifier / replay scripts of this release.
+
+## Recommended license for this package
+
+**CC BY 4.0.** Rationale:
+
+* the largest share of the derived content (compound identities, molecular formulas,
+  metadata, source-row pointers) comes from MSnLib under CC BY 4.0, so redistribution must
+  keep at least that attribution requirement;
+* the split assignments and the derived tables added by UltraMS are released under the same
+  permissive, attribution-preserving terms so that the whole package has one simple
+  license;
+* a single license keeps the benchmark usable for academic and commercial research.
+
+If you redistribute this package, keep `NOTICE.md`, `README.md` and `SHA256SUMS`, and cite
+MSnLib and UltraMS as described in `README.md` §12.
+
+## Third-party names
+
+MSnLib, UltraMS, RDKit, Nature Methods and Zenodo are names/trademarks of their respective
+owners. Their use here is descriptive only and does not imply endorsement.

README.md

@@ -0,0 +1,424 @@
+# UltraMS MSnLib benchmark
+
+Version **1.0.0** · 2026-11-04 · license **CC BY 4.0** (see [NOTICE.md](NOTICE.md))
+
+Two frozen, independent benchmark splits of the [MSnLib](https://doi.org/10.1038/s41592-025-02813-0)
+tandem mass spectral library, built and released by UltraMS:
+
+* **Split A — UltraMS MSnLib formula-level split**: the complete library (560,084 spectra,
+  all adducts) split by molecular formula into train / validation / test
+  (16,885 / 2,110 / 2,112 formulas, 446,667 / 55,980 / 57,437 spectra). Formula-disjoint.
+  This is the population for single-spectrum candidate ranking, multiple-spectrum voting,
+  label-blind grouping and embedding analyses.
+* **Split B — strict-adduct molecule-level split**: the strict `[M+H]+` and `[M-H]-`
+  subsets (447,956 source rows) re-split 70 / 15 / 15 at the level of RDKit canonical
+  isomeric SMILES, separately per polarity, with frozen queries and libraries for
+  spectrum-to-spectrum library search. Molecule-disjoint within each polarity.
+
+Both splits are frozen benchmark definitions with published checksums; neither is a
+redistribution of the MSnLib spectra.
+
+---
+
+## 1. At a glance
+
+| | Split A (formula-level, all adducts) | Split B `[M+H]+` | Split B `[M-H]-` |
+| --- | ---: | ---: | ---: |
+| compounds / molecules | — (21,107 formulas) | 41,348 | 21,293 |
+| spectra | 560,084 | 301,636 | 140,193 |
+| train | 16,885 formulas · 446,667 spectra | 28,944 compounds · 211,745 spectra | 14,907 · 98,401 |
+| validation | 2,110 formulas · 55,980 spectra | 6,202 compounds · 44,881 spectra | 3,193 · 20,927 |
+| test | 2,112 formulas · 57,437 spectra | 6,202 compounds · 45,010 spectra | 3,193 · 20,865 |
+| test task | candidate ranking / voting (57,437 queries) | 6,202 queries vs 295,434 library spectra | 3,193 vs 137,000 |
+| queries with an exact-adduct library positive | — | 6,201 | 3,160 |
+| validation task | — | 6,202 vs 250,424 | 3,193 vs 116,135 |
+
+Split A test fold: 57,437 spectra, 2,112 formulas, 5,003 distinct MSnLib source SMILES,
+4,889 distinct RDKit canonical isomeric SMILES. The **official** multiple-spectrum voting
+unit is the MSnLib source SMILES string: 5,002 groups covering 57,436 spectra (canonical
+view: 4,888 groups).
+
+Split B split seeds: 42 (`[M+H]+`) / 43 (`[M-H]-`); query seed 119. Split A has no seed:
+its fold assignment is frozen in the `fold` column of `MSnLib.csv` and replayed exactly by
+`split_A_full_msnlib/build_split_a.py`.
+
+## 2. Disjointness: what is claimed — and what is not
+
+| split | disjointness unit | claimed |
+| --- | --- | --- |
+| A | molecular formula | every spectrum of a formula lies in exactly one fold; no formula occurs in two folds (0 conflicts out of 21,107) |
+| B | RDKit canonical isomeric SMILES, per polarity | the train / validation / test compound sets of each polarity are pairwise disjoint |
+
+**A and B are different objects and must not be combined into a global-disjointness claim.**
+About 41 % of split-B compounds are in a *different* split-A fold, and a spectrum can be a
+split-A test spectrum while its compound is a split-B train compound. Concrete numbers:
+
+* split B `[M+H]+` test compounds: 654 are split-A test, 4,922 are split-A train, 626 are
+  split-A validation;
+* split B `[M-H]-` test compounds: 303 are split-A test, 2,541 are split-A train, 349 are
+  split-A validation;
+* 31,570 split-A test spectra are `[M+H]+` rows of split B and 13,413 are `[M-H]-` rows.
+
+The full cross-tabulation (compound level and spectra level, per polarity, plus the
+relation of the split-A test fold to split B) is in [figures_mapping.md](figures_mapping.md) §2.
+Never report a cross-split score as a held-out result: train and evaluate inside one split.
+
+## 3. Package layout
+
+```text
+ultrams_msnlib_benchmark_v1/
+├── README.md                     this file
+├── figures_mapping.md            which manuscript panel uses which split (+ cross-split statistics)
+├── VERIFY.md                     full verification record and reproducible commands
+├── NOTICE.md                     MSnLib attribution, provenance and licensing
+├── SHA256SUMS                    checksums of every file except itself
+├── stats.json                    machine-readable release summary (all counts + file hashes)
+├── split_A_full_msnlib/          split A (formula-level, full library)
+│   ├── README.md
+│   ├── VERIFY.md                 split-A verification record
+│   ├── REPORT.json               split-A machine-readable report
+│   ├── build_split_a.py          replay of split A from MSnLib.csv + hash check
+│   ├── formula_split.csv(.gz)                21,107 formulas → fold, n_spectra
+│   ├── row_formula_fold.csv(.gz)             560,084 rows → formula, fold
+│   ├── test_spectra.csv(.gz)                 57,437 test spectra
+│   ├── val_spectra.csv(.gz)                  55,980 validation spectra
+│   ├── test_molecules_voting.csv(.gz)        5,002 official source-SMILES voting units
+│   ├── test_molecules_voting_canonical_view.csv(.gz)  4,888 canonical-SMILES alternative view
+│   └── msnlib_rt.csv.gz                      560,084 row_index → retention time (seconds)
+├── splits/                       split B compound tables (70/15/15, per polarity)
+│   ├── pos_compound_split.csv(.gz)           41,348 compounds
+│   └── neg_compound_split.csv(.gz)           21,293 compounds
+├── queries/                      split B query spectra
+│   ├── pos_val_queries.csv(.gz)              6,202
+│   ├── pos_test_queries.csv(.gz)             6,202
+│   ├── neg_val_queries.csv(.gz)              3,193
+│   └── neg_test_queries.csv(.gz)             3,193
+├── libraries/                    split B library spectra
+│   ├── pos_val_library.csv(.gz)              250,424
+│   ├── pos_test_library.csv(.gz)             295,434
+│   ├── neg_val_library.csv(.gz)              116,135
+│   └── neg_test_library.csv(.gz)             137,000
+├── protocol/                     frozen split-B protocol arrays and manifest
+│   ├── manifest_summary.json
+│   ├── protocol_{pos,neg}.npz
+│   ├── smiles_{pos,neg}.json
+│   ├── adducts_{pos,neg}.json
+│   ├── derived/row_metadata_{pos,neg}.npz
+│   └── README.md
+├── rebuild/
+│   ├── build_library_manifest.py the split-B producer (replays MSnLib.csv)
+│   ├── baseline_common.py        its helper module
+│   ├── verify_release.py         self-contained verifier for the whole package
+│   ├── LICENSE-APACHE-2.0.txt
+│   └── README.md
+├── hf_dataset_card.md            Hugging Face dataset card draft
+├── hf_upload_commands.sh         upload commands, dry-run by default, not executed
+└── zenodo_metadata.json          Zenodo deposition metadata draft
+```
+
+Every plain `.csv` has a byte-identical `.csv.gz` twin; `rebuild/verify_release.py` checks
+this, all counts, all orderings, the cross-split statistics and the checksums.
+
+## 4. Split A — UltraMS MSnLib formula-level split
+
+### 4.1 Definition
+
+For every MSnLib spectrum the neutral molecular formula is computed from the source SMILES
+with RDKit (`rdMolDescriptors.CalcMolFormula(Chem.MolFromSmiles(smiles))`). The frozen
+`fold` column of `MSnLib.csv` assigns each formula to exactly one fold; the split is the
+formula-grouped 80/10/10 partition that results. The rule was verified for all 560,084
+spectra: 21,107 formulas, none in more than one fold. This is the frozen benchmark
+definition; `build_split_a.py` replays it from `MSnLib.csv` and reproduces every table
+byte-for-byte.
+
+### 4.2 Tables
+
+| file | rows | columns |
+| --- | ---: | --- |
+| `formula_split.csv` | 21,107 | `formula, fold, n_spectra` — ordered by fold (train, valid, test) then formula |
+| `row_formula_fold.csv` | 560,084 | `row_index, formula, fold` — 0-based `MSnLib.csv` data row → formula → fold |
+| `test_spectra.csv` | 57,437 | `row_index, smiles, precursor_mz, adduct, collision_energy, fold, canonical_isomeric_smiles` |
+| `val_spectra.csv` | 55,980 | same schema for the validation fold |
+| `test_molecules_voting.csv` | 5,002 | `group_id, smiles, n_spectra` — **official** voting units (MSnLib source SMILES) |
+| `test_molecules_voting_canonical_view.csv` | 4,888 | `group_id, canonical_isomeric_smiles, n_spectra` — alternative canonical view |
+| `msnlib_rt.csv.gz` | 560,084 | `row_index, rt` — per-spectrum retention time in seconds (gzipped only, see §4.5) |
+
+`row_index` is the 0-based data row of `MSnLib.csv` (physical line = data row + 2). The
+tables do not carry peak data; join on `row_index` against `MSnLib.csv` (see §8).
+
+### 4.3 Official voting units — read this before using the voting tables
+
+The **official multiple-spectrum voting units are the 5,002 MSnLib source-SMILES groups
+covering 57,436 spectra**, exactly the grouping used by the published multiple-spectrum
+voting task (Figure 3d and the Figure 3a voting readouts, `n_molecules = 5002`). The test
+fold contains 5,003 distinct source SMILES strings; one occurs in only one spectrum, hence
+5,002 groups. This table is `test_molecules_voting.csv` (columns `group_id, smiles,
+n_spectra`) and it is verified member-for-member against the repository voting table
+(`benchmarks/molecular_identification/data/multiple_spectrum_voting_per_group.csv.gz`).
+
+An **alternative canonical view** is provided as `test_molecules_voting_canonical_view.csv`:
+the same test spectra grouped by RDKit canonical isomeric SMILES give 4,888 groups covering
+the same 57,436 spectra (114 source-string groups merge into chemically identical
+molecules; the single excluded molecule is `CC(C)(C)OC(=O)NCC1(CC(=O)O)CCCCC1`). This view
+is not the official voting unit.
+
+No data was altered to force either count. See `split_A_full_msnlib/VERIFY.md` §7 and
+`REPORT.json` → `anomalies`.
+
+### 4.5 Retention times (RT)
+
+`split_A_full_msnlib/msnlib_rt.csv.gz` is a compact companion table needed by the
+label-blind grouping and multiple-spectrum voting analyses (Figure 3d): `row_index` is the
+0-based `MSnLib.csv` data row (0 … 560,083) and `rt` is the retention time in seconds, kept
+in the source text representation.
+
+RT is **source metadata from the MSnLib records** (CC BY 4.0, Zenodo
+10.5281/zenodo.11163380; see `NOTICE.md`). The table was exported from
+`MSnLib_with_rt.csv` (755,984,910 bytes, SHA-256
+`a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964`) after verifying
+row-by-row that its first seven columns are identical to `MSnLib.csv` in the same order
+(560,084/560,084 rows, 0 mismatches; see `split_A_full_msnlib/VERIFY.md` §5.4). The full
+756 MB CSV is not duplicated; only this 1.4 MB gzipped table is shipped.
+
+```python
+import pandas as pd
+
+test = pd.read_csv("split_A_full_msnlib/test_spectra.csv")
+rt = pd.read_csv("split_A_full_msnlib/msnlib_rt.csv.gz")   # row_index, rt
+test_rt = test.merge(rt, on="row_index", how="left")
+assert test_rt["rt"].notna().all()
+```
+
+The same `row_index` join works for every row of `row_formula_fold.csv`.
+
+#### Provenance of split A
+
+Source rows, formulas and folds were computed read-only in an isolated data-preparation
+environment with RDKit 2026.03.5. The split-A tables were frozen from that run; cross-checks against the
+historical per-fold CSV files, against the MSnLib original JSON `formula` fields, and
+against the repository voting table are recorded in `split_A_full_msnlib/VERIFY.md`.
+
+## 5. Split B — strict-adduct molecule-level split
+
+### 5.1 Definition
+
+Split B keeps only the strict `[M+H]+` (303,709 source rows) and `[M-H]-` (144,247 source
+rows) spectra. After the frozen spectrum preprocessing (drop `m/z ≤ 0` peaks, require at
+least 3 peaks, normalise to the base peak, keep the 150 most intense peaks and sort by m/z)
+2,073 positive and 4,054 negative rows are dropped, leaving **301,636** and **140,193**
+preprocessed spectra. Compound identity is RDKit canonical isomeric SMILES (frozen with
+RDKit 2026.03.5). Per polarity the sorted compound list is shuffled with
+`random.Random(42)` (`[M+H]+`) / `random.Random(43)` (`[M-H]-`) and split 70 / 15 / 15;
+one query spectrum per validation/test compound is drawn with a fresh `random.Random(119)`.
+
+### 5.2 Tables
+
+| table | schema |
+| --- | --- |
+| `splits/{pos,neg}_compound_split.csv` | `polarity, compound_id, canonical_isomeric_smiles, split, n_spectra, n_frozen_queries, n_raw_smiles_variants, first_msnlib_csv_data_row` |
+| `queries/{pos,neg}_{val,test}_queries.csv` | `polarity, split, query_index, compound_id, canonical_isomeric_smiles, adduct, msnlib_csv_data_row, msnlib_csv_line, precursor_mz, n_peaks, collision_energy, source_smiles_raw, n_library_positives` |
+| `libraries/{pos,neg}_{val,test}_library.csv` | same as queries with `library_index` and `compound_split` instead of `query_index`; row order is the frozen library order |
+
+### 5.3 Protocol
+
+1. Score every query against the **complete** library of its task (no candidate short list).
+2. A retrieved library spectrum is correct iff its canonical isomeric SMILES equals the
+   query's (exact same-adduct spectrum of the same molecule).
+3. Empirical FDR = `(accepted − correct) / accepted`; identification recall =
+   `correct / n_queries_with_library_positive` (6,201 / 3,160 for the two test tasks).
+   Queries without a library positive enter the FDR denominator but not the recall
+   denominator; `n_library_positives` is published per query.
+4. The **test library** is every preprocessed spectrum of the polarity except the selected
+   test queries (it therefore still contains further spectra of the test molecules; a query
+   never occurs in its own library). The **validation library** contains train and
+   validation compounds only, so test compounds never influence validation scores.
+5. Validation is for model selection only; the test fold is evaluated once.
+
+The split-B tables deliberately do **not** carry the formula-level fold of the spectra:
+that label belongs to split A. To obtain each split-B row's split-A fold, join
+`msnlib_csv_data_row` (queries/libraries) or `first_msnlib_csv_data_row` (compound split)
+against `split_A_full_msnlib/row_formula_fold.csv`; the packaged verifier does exactly this
+for the cross-split statistics.
+
+The frozen row-index arrays behind these tables are in `protocol/`; the CSV tables are a
+human-readable view. `rebuild/build_library_manifest.py` replays them bit-for-bit from
+`MSnLib.csv`, and `rebuild/verify_release.py` checks the tables against the arrays and the
+frozen manifest.
+
+### 5.4 Cross-collision-energy subtask
+
+The cross-collision-energy library-search task uses split B test queries that were measured
+at two or more collision energies: **6,161 positive** and **2,999 negative** queries (out of
+6,202 / 3,193 split-B test queries). The task pairs a low-energy query spectrum with a
+high-energy reference library (or vice versa) and asks for the same-molecule hit; the
+query identities are a subset of the split-B test queries published here. The CE values in
+MSnLib are 15, 20, 30, 45, 60 and 75 eV. The cross-CE pairing manifest and readouts are
+part of the UltraMS repository, not of this split package.
+
+## 6. Relation to split A
+
+Split A and split B are independent; see §2 for the disjointness statement and
+[figures_mapping.md](figures_mapping.md) §2 for the full cross-tabulation. Summary: 58.9 %
+positive and 59.4 % negative split-B compounds keep the same fold in split A; 654 positive
+and 303 negative split-B test compounds are also split-A test compounds; 31,570 / 13,413
+split-A test spectra are `[M+H]+` / `[M-H]-` rows of split B.
+
+## 7. Manuscript figures
+
+[figures_mapping.md](figures_mapping.md) maps every figure panel to the split it uses:
+
+* **A**: Figure 2b, Figure 2j, Figure 3a, 3b, 3d, 3g, 3a_sp_4, 3a_sp_5 and the
+  single-spectrum baselines Top-1 table;
+* **B**: Figure 3e, 3f, 3h, 3h_sp_1 and the cross-collision-energy task (6,161 / 2,999);
+* **not this dataset**: NPLIB1 and MassSpecGym comparison panels (independent external
+  benchmarks); Figure 3c / 3i case studies are not split-defined.
+
+Candidate-ranking tables (the per-formula candidate lists behind Figure 3a/3b/3d/3g) are
+part of the UltraMS repository, not of this split package; this package provides the frozen
+queries, identities and folds they are evaluated on.
+
+## 8. Data acquisition and rebuilding
+
+### 8.1 The spectra are not part of this manifest
+
+This package publishes splits and identifiers, not peak arrays. Every table is joined back
+to the spectra through `row_index` / `msnlib_csv_data_row`, which point into `MSnLib.csv`;
+both large files are hosted in the same Hugging Face dataset (see the managed-file table
+below) rather than duplicated in this manifest.
+
+| item | value |
+| --- | --- |
+| file | `MSnLib.csv` — one row per MSnLib spectrum |
+| rows | 560,084 data rows (560,085 physical lines, no embedded newlines) |
+| bytes | 752,707,651 |
+| SHA-256 | `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07` |
+| columns | `mzs, intensities, smiles, precursor_mz, adduct, collision_energy, fold` |
+| CSV format | peaks stored as comma-separated strings (`mzs`, `intensities`), one spectrum per row |
+
+**Managed files on Hugging Face.** The dataset is planned for Hugging Face under the
+placeholder id **`dsadd4/UltraMS-MSnLib-Benchmark`** (dataset card and upload commands are
+drafted here as `hf_dataset_card.md` and `hf_upload_commands.sh`; the upload has **not**
+been executed). The repository will host:
+
+| hosted file | bytes | SHA-256 | purpose |
+| --- | ---: | --- | --- |
+| every file of this manifest (`split_A_full_msnlib/`, `splits/`, `queries/`, `libraries/`, `protocol/`, `rebuild/`, docs; 59 files) | ≈ 185.2 MiB total | see `SHA256SUMS` | the two benchmark splits, verifier, docs |
+| `split_A_full_msnlib/msnlib_rt.csv.gz` | 1,483,069 | `994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8` | compact per-spectrum retention time (`row_index, rt` in seconds); joins `MSnLib.csv` rows 1:1 and supplies the RT used by the label-blind grouping analysis (Figure 3d) |
+| `MSnLib.csv` | 752,707,651 | `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07` | the full source CSV: one row per MSnLib spectrum; every `row_index` / `msnlib_csv_data_row` / `first_msnlib_csv_data_row` pointer resolves here |
+| `MSnLib_candidates.json` | 1,368,264,026 | `125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc` | candidate SMILES lists behind the single-spectrum candidate-ranking task: a JSON object mapping a query SMILES string to its candidate SMILES list (9,886 query entries) |
+
+The large files are hosted because every table points into them: spectra (`MSnLib.csv`) and
+candidate rankings (`MSnLib_candidates.json`). The upload script keeps them in a separate
+step and remains dry-run by default.
+
+It can also be rebuilt from the **MSnLib original release** (Brungs et al., Zenodo
+[10.5281/zenodo.11163380](https://doi.org/10.5281/zenodo.11163380), CC BY 4.0): the release
+provides 18 per-file MS2 JSONL record lists with exactly 560,084 records in total (equal to
+the CSV data-row count), each record carrying `peaks`, `smiles`, `precursor_mz`, `adduct`
+and `collision_energy`. The UltraMS CSV conversion writes one row per record in the frozen
+conversion order with the columns above and carries the frozen fold labels. The
+authoritative row → formula → fold mapping is shipped independently as
+`split_A_full_msnlib/row_formula_fold.csv`, so downstream work never depends on
+reconstructing the conversion order.
+
+### 8.2 Rebuilding split A
+
+```bash
+python3 split_A_full_msnlib/build_split_a.py \
+    --csv /path/to/MSnLib.csv \
+    --output-dir replay_split_a
+```
+
+Needs Python ≥ 3.10 and RDKit 2026.03.5 (the frozen canonicalisation runtime). The script
+verifies all counts and all six table SHA-256 values; with a different RDKit patch release
+the canonical-string tables can differ textually while every count still matches (the
+script reports that, or downgrades it to a warning with `--lenient-rdkit`).
+
+### 8.3 Rebuilding split B
+
+See [rebuild/README.md](rebuild/README.md). In short:
+
+```bash
+python3 rebuild/build_library_manifest.py \
+    --csv /path/to/MSnLib.csv --skip-reference-regression \
+    --output-dir replay_manifest
+```
+
+This regenerates `protocol/*.npz`, `smiles_*.json`, `adducts_*.json` and
+`manifest_summary.json` (needs NumPy, h5py, RDKit). The CSV tables are then rebuilt from the
+protocol arrays through `protocol/derived/row_metadata_*.npz` (see `protocol/README.md`).
+
+## 9. Verification
+
+```bash
+python3 rebuild/verify_release.py     # self-contained; no network, no MSnLib download
+sha256sum -c SHA256SUMS              # or: shasum -a 256 -c SHA256SUMS (macOS)
+```
+
+`rebuild/verify_release.py` re-derives every published count, ordering hash, disjointness
+statement, query/library partition, per-query library positive, cross-split statistic and
+file checksum from the shipped files; the complete transcript is in [VERIFY.md](VERIFY.md).
+Split-A-specific evidence (including the read-only replay and the voting-unit check) is in
+`split_A_full_msnlib/VERIFY.md`.
+
+## 10. Known properties and caveats
+
+1. **Two splits, two disjointness units.** Split A is formula-disjoint; split B is
+   compound-disjoint within each polarity. Do not merge them into one global-disjointness
+   claim and do not reuse a fold label across splits (§2).
+2. **Voting units: official 5,002 source-SMILES groups / 57,436 spectra, alternative
+   canonical view 4,888 groups / 57,436 spectra.** The official unit is the one used by the
+   published `n_molecules = 5002` grouping; both tables are shipped (§4.3).
+3. **Retention times are split-A row metadata.** `split_A_full_msnlib/msnlib_rt.csv.gz`
+   (`row_index, rt` in seconds) is source metadata from the MSnLib release, verified
+   row-aligned to `MSnLib.csv`; it is not part of split B and carries no fold label of its
+   own.
+4. **Queries without a library positive are expected** in split B: 1 positive and 33
+   negative *test* queries (and 8 / 30 *validation* queries) are singleton compounds whose
+   only spectrum is the query. They enter the FDR denominator but not the recall
+   denominator; `n_library_positives` is published per query.
+5. **Singleton compounds are retained** in split B (39 positive and 202 negative compounds
+   have exactly one spectrum). Filtering them changes the benchmark.
+6. **Compound identity is frozen text** (RDKit 2026.03.5 canonical isomeric SMILES). Other
+   RDKit patch releases can serialise the same molecule differently; compare the published
+   strings, not freshly canonicalised ones. Molecular formulas are stable across RDKit
+   patch releases.
+7. **Precursor m/z** is the source CSV text value; the split-B protocol stores it as
+   float32 and all 441,829 preprocessed rows agree exactly after the cast.
+8. **Collision energy is source metadata**, not a selection criterion; all six values
+   (15, 20, 30, 45, 60, 75 eV) occur in both polarities.
+9. **Split B libraries are large by design** (≈47.6 positive / ≈42.9 negative spectra per
+   query on average); ranking must cover the full library, there is no candidate short list.
+10. **Split A includes all adducts** (11 distinct adducts in the test fold), not only the
+   strict `[M+H]+` / `[M-H]-` subset used by split B.
+
+## 11. Provenance and licensing
+
+The upstream MSnLib release (spectra and molecule metadata) is CC BY 4.0 (Brungs et al.,
+Zenodo 10.5281/zenodo.11163380). The split definitions, tables and scripts added by UltraMS
+are released under CC BY 4.0 as well. `rebuild/build_library_manifest.py` and
+`rebuild/baseline_common.py` are Apache-2.0 files copied from the UltraMS public release.
+See [NOTICE.md](NOTICE.md) for the full attribution and licensing statement, and
+`protocol/manifest_summary.json` for the frozen split-B manifest (one path field is
+redacted to a placeholder; every count, seed and hash is byte-identical).
+
+## 12. Citation
+
+If you use this benchmark, please cite MSnLib and UltraMS:
+
+* MSnLib: Brungs C., Schmid R., Pluskal T. *MSnLib: efficient generation of open
+  multi-stage fragmentation mass spectral libraries.* Nature Methods (2025),
+  doi:10.1038/s41592-025-02813-0; data: Zenodo 10.5281/zenodo.11163380 (CC BY 4.0).
+* UltraMS: Li Y., Zhong Y., Liu P., Xia J. *UltraMS* (manuscript in preparation;
+  code: <https://github.com/Dsadd4/UltraMS>).
+
+Machine-readable citation metadata is in [`zenodo_metadata.json`](zenodo_metadata.json) and
+[`hf_dataset_card.md`](hf_dataset_card.md).
+
+## 13. Versioning
+
+`1.0.0` is the first joint release of splits A and B. Its content is defined by
+`stats.json`, `SHA256SUMS` and the frozen `protocol/manifest_summary.json`. Any change to
+the splits, the compound/formula identity or the library scope requires a new version
+directory and new manifests — the frozen tables must stay frozen so that published
+FDR/recall/ranking numbers remain comparable.

SHA256SUMS

@@ -0,0 +1,60 @@
+65f9b5fa3b480f9bfae9945d1378cb038af4a92b3c089deb1b237916ba6b732a  NOTICE.md
+f220ec2683bb5f2a027544f6cd551a00d92e182f02cfc941c0f2b9f561e6a9d1  README.md
+bd39a17757949532c6b35b41cdeeb5cce11eb6bde2e9db138f11fdc4038421d5  VERIFY.md
+5e96809613cb866fd39988ecffe396b1ac6d1788743603c498acbff67814372d  figures_mapping.md
+8eb64ecf94c13d4c36fa069782a0a4baa84fede3af16049a64299e682493d4fa  hf_dataset_card.md
+357526d01bf04d8a1423a5a3b6b3da948aa326336e8bc2350de225144ac671f0  hf_upload_commands.sh
+d0ebc03945ef98d0ab812461f1bf5ac3aeb739d01022ff39e16fe389adba75ad  libraries/neg_test_library.csv
+e1d9a677f399a8c3ebadb8d8851fb95cf2a3c33800bb22333360aaef65f82048  libraries/neg_test_library.csv.gz
+9af61236009ea964ca36648ed7159dcea67d7cac69af753998006ac84aab0b2e  libraries/neg_val_library.csv
+350374662395d238ab050c36cc9d61f100b51efb6e93f6ea5fea88c96ef90721  libraries/neg_val_library.csv.gz
+42ce92e4f7b38235cda9aaf4b0e920af7b57dc6baee269932caeb6e1f5eec862  libraries/pos_test_library.csv
+967f23c327a738febccd50c6db405ec1d59b10e0daedc559a347bf114da4ac3b  libraries/pos_test_library.csv.gz
+9c9b0d8a9f9c12fc3ccef32da2ea9909214c401e762fb679389167f5debe5852  libraries/pos_val_library.csv
+3fad6edbd573b9c65286d7c75968881566e280fdfe1b782318b928cce0b6fd74  libraries/pos_val_library.csv.gz
+bdd82008e3c59a7539199b40016872c942d59154b847c77acbcc05a6e76e30bc  protocol/README.md
+6d2086ae948fe762ee80695f8f04505516b1259bd9c5ce3719ff47fa951622b5  protocol/adducts_neg.json
+cafcaae472d3dda2337afb48801e37d9f3a318f5bcfcc9ca013f61815066ccd0  protocol/adducts_pos.json
+e566e864b2a8e34d222a7442f8e561367c92cd8d3d80c12246c0320efe5e7374  protocol/derived/row_metadata_neg.npz
+02aee46a092b4950fa46a5bded773e1946a1296a42aa33e45a8ed24313813b24  protocol/derived/row_metadata_pos.npz
+6129ed094df59265a684f436da146ef554d9c774e01768363bf58704f87ec237  protocol/manifest_summary.json
+7183fca678aa0f97dffdc6f4d4719ac993ca97592e0a468680893d0c0f3741db  protocol/protocol_neg.npz
+51a4a10ee4752b3e9bacd08084ec50a802aa4d852c5d599295fd62d99155f537  protocol/protocol_pos.npz
+15a4ed45dd55ef27d05ad7a0a14ffcaa9a86e62f5f2120a18c358f748a98b989  protocol/smiles_neg.json
+bd4514be073297afd51ad3700661d0a15b2a223b1ebffd449a6a1f4084be6b8f  protocol/smiles_pos.json
+973e3a0d7ace69760291b87b3c9a606d2aa0805f1fdbc803bace3cdf3f1303f6  queries/neg_test_queries.csv
+95fb67a3e43dcee01e1356fa6cfc8f6ed1f14bacc9c07a0ffdf4bba4de6fad24  queries/neg_test_queries.csv.gz
+dfa1e331a5f8faa00c3f1bed7f28c2aa82eec15c1b41c1d7e4ef8ac4b16d0ef0  queries/neg_val_queries.csv
+9a728d2cc2d2ea1ebfa2789bcdb9368e3e752e6121aefeda4aa88d0e5dbfca28  queries/neg_val_queries.csv.gz
+35f52f575dda7759076a68d3c789e5fe34925967a76a10397c19e6f92022f693  queries/pos_test_queries.csv
+839bcfaaed05f8a38638385c01df776626156d43127f40a61ccdfe7c197c9fc9  queries/pos_test_queries.csv.gz
+9d8bf61b62012b1988fd9cbe14a6831dba92ac1d05b3a087928461a6ea7fd986  queries/pos_val_queries.csv
+6b49651ae096ebb313568c9b48789f61f63192eaaf73f1a611c6fb8716bb8268  queries/pos_val_queries.csv.gz
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  rebuild/LICENSE-APACHE-2.0.txt
+5df97c810ff6600bab35a67fe92662f4979feb0b5fe66d8db7ce395ae81f3ce5  rebuild/README.md
+72969bc51f39dc8ae044ebaf47cdd3546f90b32edfc2b467c356b10ff0232000  rebuild/baseline_common.py
+969760ce3a1a1f85e7bcd3e2b9c9c042675624e6df6940ee6a79a124877930e3  rebuild/build_library_manifest.py
+3feac7c761dd3bce05c55847c83e97700c2cc018a13f4d6f37633e5fca7eedf6  rebuild/verify_release.py
+58a650850a9ed63c1c2a9b7593f9c392322b0f802bbeddc400b600a656ec664c  split_A_full_msnlib/README.md
+20a06ed04036fddbd757f90006a39f339fc45562237bd3e22a28e052f9b5b1dc  split_A_full_msnlib/REPORT.json
+2cde59c95c6633807b5b87fd43e3eb17a8fa5c2dac21f9541f29c5193ec1aa4e  split_A_full_msnlib/VERIFY.md
+00d07d8711af4282ae5984cee6d46b8b7ddf0f6baa62077fc748b46453e770bf  split_A_full_msnlib/build_split_a.py
+fcc44d1996d25306c884a6f8da30c1447fbe74f93c6fa12a3f271c0475a704b8  split_A_full_msnlib/formula_split.csv
+d52d77139c06d8662972fa638981894cf9f88fb3a5da1e1b73017b939d19fd4a  split_A_full_msnlib/formula_split.csv.gz
+994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8  split_A_full_msnlib/msnlib_rt.csv.gz
+ac6113867fdda683304533f097fc7287c13271a2deac8e792d1316dcf00264ff  split_A_full_msnlib/row_formula_fold.csv
+86150a89fb601a117d43c995065c3abc95ab0710cb80ffe47dfa5413aa57e686  split_A_full_msnlib/row_formula_fold.csv.gz
+edad6ec7d6b6f9fc4763deac5245207aee767c78661532621c87acc5a9b1ee07  split_A_full_msnlib/test_molecules_voting.csv
+72ae163ce88b15d89fb1d556fbb8a698d001dd1e923df11399df13dfddec3db2  split_A_full_msnlib/test_molecules_voting.csv.gz
+9fcd16ff4159e665833ea145848f94bee7c44115f4a858dd75fe486f15e92bd0  split_A_full_msnlib/test_molecules_voting_canonical_view.csv
+332c03eab3e9f91b0f956c59cd01c22f633166bd285e9942f5507839625f5bc0  split_A_full_msnlib/test_molecules_voting_canonical_view.csv.gz
+f2a870ba8ac9a54a36feaf1ecc12929ad9250ade2d082dc31454028c4b66b548  split_A_full_msnlib/test_spectra.csv
+afb5c538d969bbfccd626a02a78572083a0830a8af0c52a39a45403e3ec71352  split_A_full_msnlib/test_spectra.csv.gz
+f4fa5e0f8875991bf9df2bcb67a05437271ee18c317f33d9108f3ec28a887a82  split_A_full_msnlib/val_spectra.csv
+d2e45289b564b40998479e7c3fe7b283097f1a9aebe798e369b259c7f1851cce  split_A_full_msnlib/val_spectra.csv.gz
+d961586838f3601a7dc35a788105cab5e2cfd601df3e5604a6e5f9a18425f5a6  splits/neg_compound_split.csv
+b5a104342d57249ec4633558b324c04eb5fe5491345ff872a91d5271fe9853e8  splits/neg_compound_split.csv.gz
+b3ee3261afca60e3195bef739b45b7a4f1f27935f153455ee7dca985d8cb4398  splits/pos_compound_split.csv
+fe2e8c2c970c685a1b1fc28c957c4a3abc2e5eabef0dad77f0e81c9fbdf1ed04  splits/pos_compound_split.csv.gz
+c6817d22237ec92f5187e0595020f63b07c2a864f8610b7d946ce9ce1d299fe7  stats.json
+af1a18d25e14f24a35c308ec9f695777d6268a2ee505553b0b590be85babc412  zenodo_metadata.json

VERIFY.md

@@ -0,0 +1,338 @@
+# VERIFY — verification record for ultrams_msnlib_benchmark_v1
+
+Every number, ordering and overlap statement in this package was re-derived from the frozen
+protocol artifacts and checked against the CSV tables shipped here. No discrepancy was
+found. This file records **what was checked, how, and with which exact values**, including
+the checks that can only be performed against the original data-preparation-side artifacts.
+
+The package consists of two independent splits. Split-A-specific evidence (counts,
+cross-checks against the MSnLib original JSON `formula` fields, the repository voting
+table, and the read-only replay of all six split-A tables) is recorded in
+[`split_A_full_msnlib/VERIFY.md`](split_A_full_msnlib/VERIFY.md); this file summarises it
+and covers the split-B payload, the cross-split statistics, and the release integrity.
+
+## 1. Environments
+
+| side | runtime |
+| --- | --- |
+| frozen split-B manifest producer / split-A table producer (isolated data-preparation environment, read-only) | Linux, Python 3.10.12, NumPy 2.2.6, h5py 3.16.0, RDKit 2026.03.5 |
+| this verification run (local) | macOS, Python 3.13.11, NumPy 2.4.4, pandas 3.0.3, RDKit 2026.03.3 |
+
+Access to the data-preparation environment was **read-only**: `MSnLib.csv` and small metadata files
+were streamed out; nothing was written or modified on the remote side.
+
+## 2. Inputs actually used
+
+| input | identity |
+| --- | --- |
+| `MSnLib.csv` | 560,084 data rows, 560,085 physical lines (no embedded newlines), 752,707,651 bytes, SHA-256 `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07` |
+| frozen split-B manifest | `fig3h_manifest_strict_adduct_v4`, original SHA-256 `b83656b2b4d265d1d4ea49df30372e844e207863a7ab768f44f241bd68b8186e`; shipped copy redacted in one path field, SHA-256 `6129ed094df59265a684f436da146ef554d9c774e01768363bf58704f87ec237` |
+| frozen preprocessed spectra (not redistributed) | 110,091,598 bytes, SHA-256 `9296d42e060e7019604e16b20ba80ae13128e03b3e8ee912ee2efeb60bafdf59`; only its small metadata columns are shipped in `protocol/derived/` |
+| MSnLib original release (formula cross-check) | 18 per-file MS2 JSONL record lists, 560,084 records total, Zenodo 10.5281/zenodo.11163380, CC BY 4.0 |
+| repository multiple-spectrum voting table (voting-unit cross-check) | `benchmarks/molecular_identification/data/multiple_spectrum_voting_per_group.csv.gz` (5,002 groups, 57,436 spectra) |
+| hosted candidate file (not part of this manifest) | `MSnLib_candidates.json`, 1,368,264,026 bytes, SHA-256 `125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc`; candidate SMILES lists for the single-spectrum candidate-ranking task |
+| retention-time source | `MSnLib_with_rt.csv`, 755,984,910 bytes, SHA-256 `a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964`, columns `mzs,intensities,smiles,precursor_mz,adduct,collision_energy,fold,rt` |
+| retention-time table (shipped) | `split_A_full_msnlib/msnlib_rt.csv.gz`, 1,483,069 bytes, SHA-256 `994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8`, 560,084 rows |
+
+## 3. Split A — formula-level split (summary)
+
+Read-only replay in the isolated data-preparation environment with RDKit 2026.03.5 (`split_A_full_msnlib/build_split_a.py`)
+reproduced every count and **all six table SHA-256 values byte-for-byte**:
+
+| quantity | observed |
+| --- | --- |
+| data rows | 560,084 |
+| unique molecular formulas | 21,107 |
+| formulas train / validation / test | 16,885 / 2,110 / 2,112 |
+| spectra train / validation / test | 446,667 / 55,980 / 57,437 |
+| formulas occurring in more than one fold | 0 |
+| RDKit SMILES parse failures | 0 (48,597 distinct source SMILES) |
+| test spectra | 57,437 (2,112 formulas, 5,003 source SMILES, 4,889 canonical molecules) |
+| official voting units — MSnLib source SMILES | 5,002 groups / 57,436 spectra |
+| alternative canonical view — RDKit canonical isomeric SMILES | 4,888 groups / 57,436 spectra |
+
+Cross-checks: the test and validation spectra tables match the historical `MSnLib_test.csv` /
+`MSnLib_val.csv` row by row on `smiles`, `precursor_mz`, `adduct`, `collision_energy`
+(0 mismatches); the RDKit formula agrees with the recorded `formula` field of the MSnLib
+original JSON records (18/18 first records, 0 mismatches over 37,177 streamed records, and
+all three located C10H10BrN5O2 records); the MSnLib-source-SMILES voting table is
+member-for-member identical to the repository voting table. Details:
+[`split_A_full_msnlib/VERIFY.md`](split_A_full_msnlib/VERIFY.md).
+
+## 4. Split B — strict-adduct molecule-level split
+
+`rebuild/verify_release.py` re-derived from the shipped CSV tables and the frozen
+`protocol/` arrays:
+
+* counts against `protocol/manifest_summary.json` (compounds, spectra, queries, libraries,
+  valid/dropped rows, per-query exact-adduct library positives 6,201 / 3,160);
+* ordered query / library SMILES SHA-256 and source-row SHA-256 values for both polarities
+  and both folds;
+* table row order equals the frozen `query_index` / `library_index`;
+* query↔library row disjointness, the test partition of all preprocessed rows, one query
+  per validation/test compound, library fold scope;
+* table ↔ `protocol_*.npz` row-id mapping and `precursor_mz` / `n_peaks` agreement with the
+  frozen row metadata;
+* compound-level disjointness of the train / validation / test sets per polarity, and the
+  cross-polarity relation recorded in `stats.json` (354 shared positive/negative test
+  compounds).
+
+All 97 split-B checks passed. The ordered-sequence hashes for both test tasks are:
+
+| task | queries | library |
+| --- | --- | --- |
+| `[M+H]+` test | `356f355727380d1df02abbb0aaa3391b180a5c7b93b2103058ba54e8dfae51f0` | `4d69c6f65f8c3ed84df54fc2aa6addd7b28fd1c28909386f4e4ced88d31aacce` |
+| `[M-H]-` test | `db0aa2c39a1e5bc3c4463f97166c9d3e3ac150cba323f44bd29b636ccbd6553b` | `00dd373d9e175b070c2bd39595ee9532fdbd94f02a344897e81480e4b7784bc2` |
+
+## 5. Cross-split A × B
+
+Rebuilt from the shipped tables (`rebuild/verify_release.py`) and reproduced exactly in
+`stats.json` → `cross_split`:
+
+* all 441,829 preprocessed split-B rows exist in `row_formula_fold.csv`, each mapped to
+  exactly one split-A fold;
+* compound-level cross-tab (per polarity), spectra-level cross-tab (per split-B table and
+  role) and row-level cross-tab all reproduce the published matrices;
+* the split-A test-fold overlap counts (31,570 `[M+H]+` rows and 13,413 `[M-H]-` rows) are
+  reproduced;
+* every split-B compound maps to a single formula and therefore a single split-A fold.
+
+Key numbers (see [figures_mapping.md](figures_mapping.md) §2 for the full matrices):
+
+| quantity | `[M+H]+` | `[M-H]-` |
+| --- | ---: | ---: |
+| split-B compounds | 41,348 | 21,293 |
+| split-B compounds in the same split-A fold | 24,360 (58.9 %) | 12,645 (59.4 %) |
+| split-B test compounds that are split-A test compounds | 654 / 6,202 | 303 / 3,193 |
+| split-A test spectra inside the split-B tables | 31,570 / 57,437 | 13,413 / 57,437 |
+
+### 5.4 Retention times (split A row metadata)
+
+`split_A_full_msnlib/msnlib_rt.csv.gz` was exported from `MSnLib_with_rt.csv` after reading
+both files in parallel and comparing them row by row:
+
+| check | result |
+| --- | --- |
+| header prefix | 7-column `MSnLib.csv` header equals the first seven columns of the 8-column with-RT header | PASS |
+| rows compared | 560,084 / 560,084 | PASS |
+| first seven columns identical at every row | 0 mismatches | PASS |
+| extra rows at the end of either file | 0 / 0 | PASS |
+| unparsable RT values | 0 / 560,084 | PASS |
+| distinct RT strings | 8,369 (RT is not constant) | PASS |
+
+Shipped table: `row_index,rt`, 560,084 rows, 1,483,069 bytes, SHA-256
+`994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8`; gzipped only (no
+plain twin) to keep the package compact, and recorded in `stats.json` →
+`splits.A.retention_times` and `verification.rt_export`.
+
+## 6. Release integrity
+
+`rebuild/verify_release.py` also verifies:
+
+* every plain `.csv` is byte-identical to its `.csv.gz` twin (16 pairs);
+* `stats.json` documents exactly the shipped files (except `stats.json` and `SHA256SUMS`)
+  and every recorded byte size and SHA-256 matches;
+* `SHA256SUMS` lists every shipped file except itself and every digest matches;
+* no retired legacy project naming appears anywhere in the shipped text files (the check
+  itself is written so that the verifier does not contain the forbidden string);
+* no internal absolute paths (data-preparation workspaces, cluster scratch directories,
+  user home directories) and no private keys appear in the shipped text files.
+
+Package size: 58 shipped data/document files (plus `stats.json` and `SHA256SUMS`);
+192,701,913 bytes. The `.csv.gz`-only upload subset is ≈ 23.0 MiB; the full upload is
+≈ 183.8 MiB.
+
+## 7. Voting units: official 5,002 source-SMILES groups and 4,888 canonical groups
+
+The published multiple-spectrum voting task reports `n_molecules = 5002`. Verified
+member-for-member: those 5,002 groups are the test spectra grouped by the **MSnLib source
+SMILES string** (5,003 distinct strings, one occurring in a single spectrum → 5,002 groups
+covering 57,436 spectra). This is the **official voting unit** and is shipped as
+`split_A_full_msnlib/test_molecules_voting.csv`.
+
+An alternative chemical-deduplication view groups the same test spectra by **RDKit
+canonical isomeric SMILES**: 114 source-string groups merge into chemically identical
+molecules, giving **4,888 groups** covering the same 57,436 spectra (the single excluded
+molecule is `CC(C)(C)OC(=O)NCC1(CC(=O)O)CCCCC1`). It is shipped as
+`split_A_full_msnlib/test_molecules_voting_canonical_view.csv` and is **not** the official
+voting unit.
+
+No data was altered to force either count. Details: `split_A_full_msnlib/VERIFY.md` §7 and
+`stats.json` → `splits.A.anomaly`.
+
+## 8. What could not be verified from this package alone
+
+* The peak arrays themselves (`mzs`/`intensities`) are not part of this manifest; they are
+  hosted in the same Hugging Face dataset (`dsadd4/UltraMS-MSnLib-Benchmark`) as
+  `MSnLib.csv` (752,707,651 bytes, SHA-256
+  `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07`), together with
+  `MSnLib_candidates.json` (1,368,264,026 bytes, SHA-256
+  `125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc`). The row pointers and
+  `row_formula_fold.csv` are the authoritative link back to the spectra.
+* The historical Figure-3 analysis artifacts themselves; only the published repository
+  voting-group table and the frozen protocol arrays were cross-checked.
+* The exact physical row order of `MSnLib.csv` beyond what the shipped tables encode; the
+  package depends on the row pointers, not on reconstructing the file order.
+
+## 9. Reproduce this verification
+
+```bash
+python3 rebuild/verify_release.py          # 140 checks, exit 0
+shasum -a 256 -c SHA256SUMS               # macOS;  sha256sum -c SHA256SUMS on Linux
+```
+
+## 10. Transcript of `rebuild/verify_release.py`
+
+Unedited output against the final package contents (140 checks, exit status 0):
+
+```text
+[PASS] csv.gz twins byte-identical to plain csv
+[PASS] B/pos: protocol adduct vocabulary == [M+H]+ :: ['[M+H]+']
+[PASS] B/pos: preprocessed row metadata covers all 301,636 rows uniquely
+[PASS] B/pos: compound split counts match manifest :: {'train': 28944, 'val': 6202, 'test': 6202} vs {'test': 6202, 'train': 28944, 'val': 6202}
+[PASS] B/pos: compound vocabulary is exactly the frozen smiles vocabulary :: 41348 vs 41348
+[PASS] B/pos: compound_ids unique
+[PASS] B/pos: spectra per compound sum to manifest valid rows :: 301636
+[PASS] B/pos: split table columns are the released schema :: ['polarity', 'compound_id', 'canonical_isomeric_smiles', 'split', 'n_spectra', 'n_frozen_queries', 'n_raw_smiles_variants', 'first_msnlib_csv_data_row']
+[PASS] B/pos: train/val/test compound sets pairwise disjoint
+[PASS] B/pos: the three compound sets cover the whole vocabulary
+[PASS] B/pos/val: query count 6,202 matches manifest :: 6202 vs 6202
+[PASS] B/pos/val: library count 250,424 matches manifest :: 250424 vs 250424
+[PASS] B/pos/val: ordered query SMILES sha256 matches manifest
+[PASS] B/pos/val: ordered library SMILES sha256 matches manifest
+[PASS] B/pos/val: table row order == frozen query_index/library_index
+[PASS] B/pos/val: query rows and library rows are disjoint :: 0 shared rows
+[PASS] B/pos/val: queries are one spectrum per compound in this fold
+[PASS] B/pos/val: library compounds respect the fold scope
+[PASS] B/pos/val: query table maps to protocol_pos.npz query rows
+[PASS] B/pos/val: library table maps to protocol_pos.npz library rows
+[PASS] B/pos/val: source rows unique in each table
+[PASS] B/pos/val: n_library_positives column reproduces from the library table
+       (pos/val queries with a library positive: 6,194 / 6,202)
+[PASS] B/pos/val: adduct column is strict [M+H]+ everywhere
+[PASS] B/pos/val: csv line = data row + 2 (header offset, no embedded newlines)
+[PASS] B/pos/val: precursor_mz/n_peaks agree with frozen row metadata (queries)
+[PASS] B/pos/val: query/library table columns are the released schema
+[PASS] B/pos/test: query count 6,202 matches manifest :: 6202 vs 6202
+[PASS] B/pos/test: library count 295,434 matches manifest :: 295434 vs 295434
+[PASS] B/pos/test: ordered query SMILES sha256 matches manifest
+[PASS] B/pos/test: ordered library SMILES sha256 matches manifest
+[PASS] B/pos/test: table row order == frozen query_index/library_index
+[PASS] B/pos/test: query rows and library rows are disjoint :: 0 shared rows
+[PASS] B/pos/test: queries are one spectrum per compound in this fold
+[PASS] B/pos/test: library compounds respect the fold scope
+[PASS] B/pos/test: query table maps to protocol_pos.npz query rows
+[PASS] B/pos/test: library table maps to protocol_pos.npz library rows
+[PASS] B/pos/test: source rows unique in each table
+[PASS] B/pos/test: n_library_positives column reproduces from the library table
+[PASS] B/pos/test: queries with an exact-adduct library positive == manifest (6,201) :: 6201
+[PASS] B/pos/test: source-row hashes match manifest
+[PASS] B/pos/test: adduct column is strict [M+H]+ everywhere
+[PASS] B/pos/test: csv line = data row + 2 (header offset, no embedded newlines)
+[PASS] B/pos/test: precursor_mz/n_peaks agree with frozen row metadata (queries)
+[PASS] B/pos/test: query/library table columns are the released schema
+[PASS] B/pos: test queries + test library partition all preprocessed rows
+[PASS] B/pos: protocol train_rows all belong to train compounds
+[PASS] B/pos: protocol val_query_rows all belong to val compounds
+[PASS] B/pos: protocol test_query_rows all belong to test compounds
+[PASS] B/pos: source MSnLib.csv sha256 recorded
+[PASS] B/neg: protocol adduct vocabulary == [M-H]- :: ['[M-H]-']
+[PASS] B/neg: preprocessed row metadata covers all 140,193 rows uniquely
+[PASS] B/neg: compound split counts match manifest :: {'train': 14907, 'val': 3193, 'test': 3193} vs {'test': 3193, 'train': 14907, 'val': 3193}
+[PASS] B/neg: compound vocabulary is exactly the frozen smiles vocabulary :: 21293 vs 21293
+[PASS] B/neg: compound_ids unique
+[PASS] B/neg: spectra per compound sum to manifest valid rows :: 140193
+[PASS] B/neg: split table columns are the released schema :: ['polarity', 'compound_id', 'canonical_isomeric_smiles', 'split', 'n_spectra', 'n_frozen_queries', 'n_raw_smiles_variants', 'first_msnlib_csv_data_row']
+[PASS] B/neg: train/val/test compound sets pairwise disjoint
+[PASS] B/neg: the three compound sets cover the whole vocabulary
+[PASS] B/neg/val: query count 3,193 matches manifest :: 3193 vs 3193
+[PASS] B/neg/val: library count 116,135 matches manifest :: 116135 vs 116135
+[PASS] B/neg/val: ordered query SMILES sha256 matches manifest
+[PASS] B/neg/val: ordered library SMILES sha256 matches manifest
+[PASS] B/neg/val: table row order == frozen query_index/library_index
+[PASS] B/neg/val: query rows and library rows are disjoint :: 0 shared rows
+[PASS] B/neg/val: queries are one spectrum per compound in this fold
+[PASS] B/neg/val: library compounds respect the fold scope
+[PASS] B/neg/val: query table maps to protocol_neg.npz query rows
+[PASS] B/neg/val: library table maps to protocol_neg.npz library rows
+[PASS] B/neg/val: source rows unique in each table
+[PASS] B/neg/val: n_library_positives column reproduces from the library table
+       (neg/val queries with a library positive: 3,163 / 3,193)
+[PASS] B/neg/val: adduct column is strict [M-H]- everywhere
+[PASS] B/neg/val: csv line = data row + 2 (header offset, no embedded newlines)
+[PASS] B/neg/val: precursor_mz/n_peaks agree with frozen row metadata (queries)
+[PASS] B/neg/val: query/library table columns are the released schema
+[PASS] B/neg/test: query count 3,193 matches manifest :: 3193 vs 3193
+[PASS] B/neg/test: library count 137,000 matches manifest :: 137000 vs 137000
+[PASS] B/neg/test: ordered query SMILES sha256 matches manifest
+[PASS] B/neg/test: ordered library SMILES sha256 matches manifest
+[PASS] B/neg/test: table row order == frozen query_index/library_index
+[PASS] B/neg/test: query rows and library rows are disjoint :: 0 shared rows
+[PASS] B/neg/test: queries are one spectrum per compound in this fold
+[PASS] B/neg/test: library compounds respect the fold scope
+[PASS] B/neg/test: query table maps to protocol_neg.npz query rows
+[PASS] B/neg/test: library table maps to protocol_neg.npz library rows
+[PASS] B/neg/test: source rows unique in each table
+[PASS] B/neg/test: n_library_positives column reproduces from the library table
+[PASS] B/neg/test: queries with an exact-adduct library positive == manifest (3,160) :: 3160
+[PASS] B/neg/test: source-row hashes match manifest
+[PASS] B/neg/test: adduct column is strict [M-H]- everywhere
+[PASS] B/neg/test: csv line = data row + 2 (header offset, no embedded newlines)
+[PASS] B/neg/test: precursor_mz/n_peaks agree with frozen row metadata (queries)
+[PASS] B/neg/test: query/library table columns are the released schema
+[PASS] B/neg: test queries + test library partition all preprocessed rows
+[PASS] B/neg: protocol train_rows all belong to train compounds
+[PASS] B/neg: protocol val_query_rows all belong to val compounds
+[PASS] B/neg: protocol test_query_rows all belong to test compounds
+[PASS] B/neg: source MSnLib.csv sha256 recorded
+[PASS] B: cross-polarity pos-test x neg-test intersection reproduces stats.json :: 354 vs 354
+[PASS] A: formula_split columns :: ['formula', 'fold', 'n_spectra']
+[PASS] A: formula_split has 21,107 unique formulas
+[PASS] A: formula fold values are train/val/test
+[PASS] A: formula-level counts 16,885 / 2,110 / 2,112 :: {'train': 16885, 'val': 2110, 'test': 2112}
+[PASS] A: spectra counts 446,667 / 55,980 / 57,437 :: {'train': 446667, 'val': 55980, 'test': 57437}
+[PASS] A: total spectra = 560,084
+[PASS] A: row_formula_fold covers rows 0..560,083 in order
+[PASS] A: every formula occurs in exactly one fold
+[PASS] A: row_formula_fold agrees with formula_split (fold and n_spectra)
+[PASS] A: row-level fold totals match formula_split
+[PASS] A: test_spectra columns are the released schema :: ['row_index', 'smiles', 'precursor_mz', 'adduct', 'collision_energy', 'fold', 'canonical_isomeric_smiles']
+[PASS] A: test_spectra has 57,437 rows, all fold=test
+[PASS] A: test_spectra row_index equals the rows marked test in row_formula_fold
+[PASS] A: val_spectra has 55,980 rows, all fold=val
+[PASS] A: val_spectra row_index equals the rows marked val in row_formula_fold
+[PASS] A: official voting-unit table columns are group_id, smiles, n_spectra :: ['group_id', 'smiles', 'n_spectra']
+[PASS] A: official voting-unit table (MSnLib source SMILES) reproduces from test_spectra
+[PASS] A: official voting-unit table has 5,002 groups / 57,436 spectra
+[PASS] A: canonical-view table columns are group_id, canonical_isomeric_smiles, n_spectra :: ['group_id', 'canonical_isomeric_smiles', 'n_spectra']
+[PASS] A: canonical-view table reproduces from test_spectra
+[PASS] A: canonical-view table has 4,888 groups / 57,436 spectra
+[PASS] A: exactly one test spectrum lies outside the voting tables :: CC(C)(C)OC(=O)NCC1(CC(=O)O)CCCCC1
+[PASS] A: retention-time companion table is shipped and matches stats.json :: split_A_full_msnlib/msnlib_rt.csv.gz
+[PASS] A: retention-time table columns are row_index, rt :: ['row_index', 'rt']
+[PASS] A: retention-time table has 560,084 rows in row order
+[PASS] A: every retention time is present and numeric :: 0 empty, 0 non-numeric
+[PASS] A/B: every split-B table row exists in row_formula_fold :: 0 missing
+[PASS] A/B: split-B tables cover all 441,829 preprocessed spectra :: 441829
+[PASS] A/B: compound-level cross tab reproduces stats.json
+[PASS] A/B: spectra-level cross tab reproduces stats.json
+[PASS] A/B: row-level split-B x split-A cross tab reproduces stats.json
+[PASS] A/B: row-level split-B totals equal the manifest split-spectra counts
+[PASS] A/B/pos: A-test rows inside the split-B tables reproduce stats.json :: 31570 vs 31570
+[PASS] A/B/neg: A-test rows inside the split-B tables reproduce stats.json :: 13413 vs 13413
+[PASS] A/B: every split-B compound has a single split-A fold (same formula)
+[PASS] stats.json documents exactly the shipped files (except stats.json and SHA256SUMS) :: missing=[] extra=[]
+[PASS] stats.json byte sizes and sha256 match every shipped file
+[PASS] SHA256SUMS parses as '<sha256>  <path>' lines
+[PASS] SHA256SUMS covers every shipped file except itself :: 60 entries
+[PASS] SHA256SUMS hashes match the files
+[PASS] no retired legacy project naming anywhere in the shipped text files
+[PASS] no internal absolute paths or private keys in the shipped text files
+
+140/140 checks passed
+```
+
+## 11. Version
+
+Release `1.0.0`, generated 2026-11-04. Any change to the tables or protocol files
+invalidates these hashes and requires a new version directory.

figures_mapping.md

@@ -0,0 +1,124 @@
+# Figure → split mapping
+
+This package contains the two frozen MSnLib splits behind the UltraMS manuscript. They are
+different objects and answer different questions:
+
+* **Split A — UltraMS MSnLib formula-level split** (`split_A_full_msnlib/`): the complete
+  MSnLib library (560,084 spectra, all adducts) split by molecular formula into 16,885 /
+  2,110 / 2,112 formulas and 446,667 / 55,980 / 57,437 spectra (train / validation / test).
+  Formula-disjoint, not molecule-disjoint. Test fold: 57,437 spectra, 2,112 formulas,
+  5,003 source SMILES / 4,889 canonical molecules.
+* **Split B — strict-adduct molecule-level split** (`splits/`, `queries/`, `libraries/`):
+  the strict `[M+H]+` and `[M-H]-` subsets (447,956 source rows) re-split 70/15/15 at the
+  level of RDKit canonical isomeric SMILES, separately per polarity, with frozen queries
+  and libraries for spectrum-to-spectrum library search. Molecule-disjoint within each
+  polarity. Test tasks: 6,202 positive and 3,193 negative queries against 295,434 and
+  137,000 library spectra.
+
+## 1. Panel mapping
+
+| figure panel | split | evaluation population / task |
+| --- | --- | --- |
+| Figure 2b — ionization-polarity recognition | **A** | polarity prediction over the split-A evaluation population (A test fold; A train / validation used for fitting and reference). |
+| Figure 2j — peak-token embedding chemical atlas | **A** | peak-token embedding visualization/analysis over the split-A test fold with split-A reference spectra; colours are chemical properties, not a model output. |
+| Figure 3a — single-spectrum candidate ranking (Hit@1/5/20) | **A** | 57,437 split-A test spectra as queries, ranked against the per-formula candidate tables used by the manuscript (candidate ranking tables are part of the UltraMS repository, not of this split package). |
+| Figure 3b — score/rank density and cumulative Top-k | **A** | same 57,437 split-A test queries and their candidate rankings. |
+| Figure 3d — multiple-spectrum voting | **A** | 57,437 split-A test spectra grouped into the **official voting units: 5,002 MSnLib source-SMILES groups covering 57,436 spectra** (`split_A_full_msnlib/test_molecules_voting.csv`); the alternative canonical-isomeric-SMILES view (4,888 groups, same 57,436 spectra) is `split_A_full_msnlib/test_molecules_voting_canonical_view.csv`; the retention times used by this analysis are `split_A_full_msnlib/msnlib_rt.csv.gz` (`row_index, rt`). See the parent `README.md` §4.3/§4.5. |
+| Figure 3g — empirical rank CDF | **A** | 57,437 split-A test queries. |
+| Figure 3a_sp_4 — label-blind consensus grouping | **A** | split-A test fold, label-blind grouping of same-molecule spectra. |
+| Figure 3a_sp_5 — promoted MSnLib fingerprint analysis | **A** | split-A fingerprint-prediction evaluation population (split-A train / validation for fitting). |
+| baselines — single-spectrum Top-1 table | **A** | 57,437 split-A test queries, one ranking per method. |
+| Figure 3e — strict-adduct library search, FDR–recall | **B** | strict `[M+H]+`: 6,202 test queries vs 295,434 library spectra (recall denominator 6,201); strict `[M-H]-`: 3,193 vs 137,000 (denominator 3,160). Validation tasks: 6,202 / 250,424 and 3,193 / 116,135. |
+| Figure 3f — cross-polarity molecular retrieval | **B** | molecule-level split-B compounds; one polarity's spectra query the other polarity's library. |
+| Figure 3h — seven-method strict-adduct FDR–recall (unused figure) | **B** | same split-B query / library sets as Figure 3e. |
+| Figure 3h_sp_1 — FDR threshold transfer | **B** | split-B validation/test query identities; 200 paired molecule-disjoint calibration/held-out assignments over those identities. |
+| cross-collision-energy search | **B** | split-B test queries that have at least two collision energies: **6,161** positive and **2,999** negative cross-CE queries (from 6,202 / 3,193 split-B test queries). |
+| NPLIB1 and MassSpecGym comparison panels | **not this dataset** | NPLIB1 (3,699 test molecules) and MassSpecGym are independent external benchmarks with their own splits and libraries; they are not derived from MSnLib and are not covered by this package. |
+| Figure 3c / Figure 3i case studies | **neither** | case-study panels use specific MSnLib spectra and MAGMa peak annotations; they are not defined by either split table. |
+
+## 2. Cross-split inconsistency: split A (formulas) vs split B (compounds)
+
+The two splits are built on different units (formula vs canonical molecule) and different
+populations (all adducts vs strict `[M+H]+`/`[M-H]-`), so their fold labels disagree for a
+large share of compounds. The tables below are computed by mapping every split-B compound
+to its molecular formula through `msnlib_csv_data_row` → `split_A_full_msnlib/row_formula_fold.csv`.
+Compound counts are split-B compounds (a compound belongs to one polarity and one split-B
+fold).
+
+### `[M+H]+` — 41,348 compounds
+
+| split B ↓ / split A → | train | validation | test | total |
+| --- | ---: | ---: | ---: | ---: |
+| **train** | 23,059 | 2,901 | 2,984 | 28,944 |
+| **validation** | 4,924 | 647 | 631 | 6,202 |
+| **test** | 4,922 | 626 | **654** | 6,202 |
+| total | 32,905 | 4,174 | 4,269 | 41,348 |
+
+Same-fold compounds: **24,360 / 41,348 (58.9 %)**.
+Of the 6,202 split-B positive test compounds only **654 (10.5 %)** are split-A test
+compounds; 4,922 (79.4 %) are split-A train compounds.
+
+### `[M-H]-` — 21,293 compounds
+
+| split B ↓ / split A → | train | validation | test | total |
+| --- | ---: | ---: | ---: | ---: |
+| **train** | 12,035 | 1,447 | 1,425 | 14,907 |
+| **validation** | 2,552 | 307 | 334 | 3,193 |
+| **test** | 2,541 | 349 | **303** | 3,193 |
+| total | 17,128 | 2,103 | 2,062 | 21,293 |
+
+Same-fold compounds: **12,645 / 21,293 (59.4 %)**.
+Of the 3,193 split-B negative test compounds only **303 (9.5 %)** are split-A test
+compounds.
+
+### Spectra-level view
+
+The split-B tables cover all 441,829 preprocessed strict-adduct spectra (301,636 positive +
+140,193 negative); each maps to exactly one split-A fold:
+
+`[M+H]+` — 301,636 preprocessed spectra:
+
+| split B ↓ / split A → | train | validation | test | total |
+| --- | ---: | ---: | ---: | ---: |
+| **train** | 168,804 | 20,917 | 22,024 | 211,745 |
+| **validation** | 35,535 | 4,604 | 4,742 | 44,881 |
+| **test** | 35,716 | 4,490 | **4,804** | 45,010 |
+| total | 240,055 | 30,011 | 31,570 | 301,636 |
+
+`[M-H]-` — 140,193 preprocessed spectra:
+
+| split B ↓ / split A → | train | validation | test | total |
+| --- | ---: | ---: | ---: | ---: |
+| **train** | 79,644 | 9,523 | 9,234 | 98,401 |
+| **validation** | 16,760 | 1,981 | 2,186 | 20,927 |
+| **test** | 16,609 | 2,263 | **1,993** | 20,865 |
+| total | 113,013 | 13,767 | 13,413 | 140,193 |
+
+The spectra-level matrix is computed from the frozen `protocol/` row metadata (each
+preprocessed row → its compound → its split-B fold) and `split_A_full_msnlib/row_formula_fold.csv`;
+the per-split totals equal the split-B `split_spectra_counts` of the frozen manifest
+(211,745 / 44,881 / 45,010 positive and 98,401 / 20,927 / 20,865 negative).
+
+(Recompute with `rebuild/verify_release.py`, which rebuilds both matrices from the shipped
+tables.)
+
+### Relation of the split-A test fold to split B
+
+* 57,437 split-A test spectra in total;
+* **31,570 (55.0 %)** are strict `[M+H]+` spectra of the split-B tables, **13,413 (23.3 %)**
+  are strict `[M-H]-` spectra; 44,983 (78.3 %) therefore lie inside split B;
+* the remaining 12,454 split-A test spectra carry other adducts (`[M+FA]-`, `[M+Cl]-`,
+  `[M+Na]+`, `[M+NH4]+`, `[M+H-H2O]+`, …) and never occur in split B.
+
+### What this means — and what must not be claimed
+
+* Split A is **formula-disjoint only**; split B is **compound-disjoint within each
+  polarity**. Each property holds only inside its own split.
+* The two splits **cannot be merged into a global-disjointness claim**: about 41 % of the
+  split-B compounds are in a different split-A fold, and the same spectrum can be a *test*
+  spectrum in split A while belonging to a *train* compound in split B (e.g. 4,922 of the
+  6,202 positive split-B test compounds are split-A train compounds).
+* A score computed on an split-A test spectrum whose compound is split-B train must not be
+  reported as a "held-out molecule" result, and vice versa. Train and evaluate within one
+  split only; if a cross-split experiment is unavoidable, state explicitly which split
+  defines the training population and which defines the test population.

hf_dataset_card.md

@@ -0,0 +1,207 @@
+---
+pretty_name: UltraMS MSnLib benchmark (formula-level split A + strict-adduct molecule-level split B)
+license: cc-by-4.0
+language:
+  - en
+size_categories:
+  - 100K<n<1M
+task_categories:
+  - other
+configs:
+  - config_name: split_A_formula_split
+    data_files: split_A_full_msnlib/formula_split.csv
+  - config_name: split_A_row_formula_fold
+    data_files: split_A_full_msnlib/row_formula_fold.csv
+  - config_name: split_A_test_spectra
+    data_files: split_A_full_msnlib/test_spectra.csv
+  - config_name: split_A_val_spectra
+    data_files: split_A_full_msnlib/val_spectra.csv
+  - config_name: split_A_test_molecules_voting_official
+    data_files: split_A_full_msnlib/test_molecules_voting.csv
+  - config_name: split_A_test_molecules_voting_canonical_view
+    data_files: split_A_full_msnlib/test_molecules_voting_canonical_view.csv
+  - config_name: split_A_msnlib_rt
+    data_files: split_A_full_msnlib/msnlib_rt.csv.gz
+  - config_name: split_B_pos_compound_split
+    data_files: splits/pos_compound_split.csv
+  - config_name: split_B_neg_compound_split
+    data_files: splits/neg_compound_split.csv
+  - config_name: split_B_pos_val_queries
+    data_files: queries/pos_val_queries.csv
+  - config_name: split_B_pos_test_queries
+    data_files: queries/pos_test_queries.csv
+  - config_name: split_B_neg_val_queries
+    data_files: queries/neg_val_queries.csv
+  - config_name: split_B_neg_test_queries
+    data_files: queries/neg_test_queries.csv
+  - config_name: split_B_pos_val_library
+    data_files: libraries/pos_val_library.csv
+  - config_name: split_B_pos_test_library
+    data_files: libraries/pos_test_library.csv
+  - config_name: split_B_neg_val_library
+    data_files: libraries/neg_val_library.csv
+  - config_name: split_B_neg_test_library
+    data_files: libraries/neg_test_library.csv
+tags:
+  - chemistry
+  - mass-spectrometry
+  - metabolomics
+  - small-molecules
+  - tandem-ms
+  - spectrum-library-search
+  - molecule-retrieval
+  - benchmark
+  - ultraMS
+---
+
+# UltraMS MSnLib benchmark
+
+Two frozen, independent benchmark splits of the [MSnLib](https://doi.org/10.1038/s41592-025-02813-0)
+tandem mass spectral library, released by UltraMS. The splits are different objects:
+
+* **Split A — UltraMS MSnLib formula-level split** (all 560,084 spectra, all adducts):
+  21,107 molecular formulas, split 16,885 / 2,110 / 2,112 formulas and
+  446,667 / 55,980 / 57,437 spectra into train / validation / test. Formula-disjoint. Test
+  fold: 57,437 spectra, 2,112 formulas, 5,003 source SMILES / 4,889 canonical molecules.
+  Population for single-spectrum candidate ranking, multiple-spectrum voting, label-blind
+  grouping, fingerprint prediction and embedding analyses (Figure 2b/2j, 3a/3b/3d/3g,
+  3a_sp_4, 3a_sp_5, single-spectrum baselines). The **official multiple-spectrum voting
+  units are the 5,002 MSnLib source-SMILES groups covering 57,436 spectra**
+  (`test_molecules_voting.csv`); a canonical-SMILES alternative view (4,888 groups) is also
+  provided (`test_molecules_voting_canonical_view.csv`). Per-spectrum retention times
+  (`row_index, rt` in seconds) are in `msnlib_rt.csv.gz` for the label-blind grouping and
+  multiple-spectrum voting analyses.
+* **Split B — strict-adduct molecule-level split** (`[M+H]+` and `[M-H]-` only): 41,348 /
+  21,293 compounds and 301,636 / 140,193 preprocessed spectra, split 70/15/15 per polarity
+  by RDKit canonical isomeric SMILES, with frozen queries and libraries for
+  spectrum-to-spectrum library search. Population for Figure 3e/3f/3h, 3h_sp_1 and the
+  cross-collision-energy task (6,161 positive / 2,999 negative queries).
+
+| split-B task | queries | library spectra | queries with an exact-adduct library positive |
+| --- | ---: | ---: | ---: |
+| `[M+H]+` test | 6,202 | 295,434 | 6,201 |
+| `[M+H]+` validation | 6,202 | 250,424 | 6,194 |
+| `[M-H]-` test | 3,193 | 137,000 | 3,160 |
+| `[M-H]-` validation | 3,193 | 116,135 | 3,163 |
+
+> **Disjointness.** Split A is formula-disjoint (no formula in two folds); split B is
+> molecule-disjoint within each polarity (the train / validation / test compound sets are
+> pairwise empty). The two splits must **not** be merged into a global-disjointness claim:
+> about 41 % of split-B compounds lie in a different split-A fold, and a spectrum can be
+> split-A test while its compound is split-B train. See the package
+> `figures_mapping.md` §2 for the full cross-tabulation.
+
+## Usage
+
+```python
+import pandas as pd
+
+base = "https://huggingface.co/datasets/dsadd4/UltraMS-MSnLib-Benchmark/resolve/main/"
+
+# split A — formula-level split of the full library
+formulas = pd.read_csv(base + "split_A_full_msnlib/formula_split.csv")
+rows = pd.read_csv(base + "split_A_full_msnlib/row_formula_fold.csv")      # 560,084 rows
+test = pd.read_csv(base + "split_A_full_msnlib/test_spectra.csv")          # 57,437 rows
+assert formulas.groupby("formula")["fold"].nunique().max() == 1
+
+# split B — strict-adduct molecule-level library search
+compound_split = pd.read_csv(base + "splits/pos_compound_split.csv")
+queries = pd.read_csv(base + "queries/pos_test_queries.csv")
+library = pd.read_csv(base + "libraries/pos_test_library.csv")
+
+positives = library.groupby("canonical_isomeric_smiles").size()
+n_pos = queries["canonical_isomeric_smiles"].map(positives).fillna(0).astype(int)
+denominator = int((n_pos > 0).sum())      # 6,201
+```
+
+With `datasets` (one config per table, see the YAML header):
+
+```python
+from datasets import load_dataset
+queries = load_dataset("dsadd4/UltraMS-MSnLib-Benchmark", "split_B_pos_test_queries", split="train")
+```
+
+Peak data are **not** part of the split tables. Every row is joined back to the spectra by
+`row_index` / `msnlib_csv_data_row` / `first_msnlib_csv_data_row`, which point into
+`MSnLib.csv`. `MSnLib.csv` and `MSnLib_candidates.json` are hosted in the same dataset; see
+**Hosted files** below.
+
+## Columns
+
+* `split_A_full_msnlib/formula_split.csv`: `formula, fold, n_spectra`
+* `split_A_full_msnlib/row_formula_fold.csv`: `row_index, formula, fold`
+* `split_A_full_msnlib/{test,val}_spectra.csv`: `row_index, smiles, precursor_mz, adduct,
+  collision_energy, fold, canonical_isomeric_smiles`
+* `split_A_full_msnlib/test_molecules_voting.csv`: `group_id, smiles, n_spectra` —
+  **official** voting units: 5,002 MSnLib-source-SMILES groups covering 57,436 spectra, the
+  grouping of the published multiple-spectrum voting task (`n_molecules = 5002`)
+* `split_A_full_msnlib/test_molecules_voting_canonical_view.csv`: `group_id,
+  canonical_isomeric_smiles, n_spectra` — alternative canonical view: 4,888 groups covering
+  the same 57,436 spectra
+* `split_A_full_msnlib/msnlib_rt.csv.gz`: `row_index, rt` — per-spectrum retention time in
+  seconds, aligned 1:1 to the `MSnLib.csv` data rows (560,084 rows)
+* `splits/*_compound_split.csv`: `polarity, compound_id, canonical_isomeric_smiles, split,
+  n_spectra, n_frozen_queries, n_raw_smiles_variants, first_msnlib_csv_data_row`
+* `queries/*.csv`: `polarity, split, query_index, compound_id, canonical_isomeric_smiles,
+  adduct, msnlib_csv_data_row, msnlib_csv_line, precursor_mz, n_peaks, collision_energy,
+  source_smiles_raw, n_library_positives`
+* `libraries/*.csv`: same as queries with `library_index` and `compound_split` instead of
+  `query_index`; row order is the frozen library order
+
+## Split-B evaluation protocol
+
+1. Score every query against the complete library of its task (no candidate short list).
+2. Correct = the top-1 library spectrum has the same canonical compound identity.
+3. Empirical FDR = `(accepted − correct) / accepted`; identification recall =
+   `correct / n_queries_with_library_positive` (6,201 / 3,160 for the two test tasks).
+   Queries without a library positive enter the FDR denominator but not the recall
+   denominator; `n_library_positives` is provided per query.
+4. The test library contains all preprocessed spectra of the polarity except the selected
+   test queries; the validation library contains train and validation compounds only.
+5. Validation is for model selection only; evaluate the test fold once.
+
+## Hosted files
+
+The dataset hosts the complete manifest plus two large source files. Every file of the
+manifest is checksummed in `SHA256SUMS`; the two large files are kept in a separate upload
+step (see `hf_upload_commands.sh`, dry-run by default).
+
+| hosted file | bytes | SHA-256 | purpose |
+| --- | ---: | --- | --- |
+| manifest: `split_A_full_msnlib/`, `splits/`, `queries/`, `libraries/`, `protocol/`, `rebuild/`, docs (59 files) | ≈ 185.2 MiB | see `SHA256SUMS` | the two benchmark splits, verifier, docs |
+| `split_A_full_msnlib/msnlib_rt.csv.gz` | 1,483,069 | `994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8` | compact per-spectrum retention time (`row_index, rt` in seconds), aligned 1:1 to `MSnLib.csv`; used by the label-blind grouping analysis |
+| `MSnLib.csv` | 752,707,651 | `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07` | full source CSV: one row per MSnLib spectrum (560,084 rows); every row pointer in the split tables resolves here |
+| `MSnLib_candidates.json` | 1,368,264,026 | `125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc` | candidate SMILES lists behind the single-spectrum candidate-ranking task: a JSON object mapping a query SMILES string to its candidate SMILES list (9,886 query entries) |
+
+`MSnLib.csv` is the UltraMS CSV conversion of the MSnLib original release (Zenodo
+10.5281/zenodo.11163380, CC BY 4.0), whose 18 per-file MS2 JSONL record lists contain the
+same 560,084 spectra. `MSnLib_candidates.json` contains candidate SMILES lists derived from
+the MSnLib compound set; both files carry the MSnLib attribution.
+
+## Provenance, verification, license
+
+* Source rows: `MSnLib.csv` (560,084 rows) converted from the MSnLib original release
+  (Brungs et al., CC BY 4.0; Zenodo 10.5281/zenodo.11163380).
+* Hosted source files: `MSnLib.csv` (752,707,651 bytes, SHA-256 `be54b330…`) and
+  `MSnLib_candidates.json` (1,368,264,026 bytes, SHA-256 `125a1cdc…`).
+* Frozen split-B manifest, seeds 42 / 43, query seed 119; frozen split-A fold assignment
+  from the `fold` column of `MSnLib.csv`.
+* `SHA256SUMS` covers every file; `rebuild/verify_release.py` is a self-contained verifier
+  that re-checks every count, ordering hash, disjointness statement, cross-split statistic
+  and checksum offline.
+* License **CC BY 4.0**, with attribution to MSnLib (CC BY 4.0); Apache-2.0 for the two
+  UltraMS producer scripts. See the package `NOTICE.md`.
+
+## Citation
+
+```bibtex
+@misc{ultrams_msnlib_benchmark_2026,
+  title  = {UltraMS MSnLib benchmark: full-library formula-level split and strict-adduct molecule-level library-search split},
+  author = {Li, Yifan and Zhong, Yunhua and Liu, Pan and Xia, Jun},
+  year   = {2026},
+  note   = {Derived from MSnLib (Brungs, Schmid, Pluskal; CC BY 4.0, Zenodo 10.5281/zenodo.11163380)},
+  howpublished = {Hugging Face / Zenodo dataset, version 1.0.0}
+}
+```
+
+Please also cite MSnLib (doi:10.1038/s41592-025-02813-0) and the UltraMS manuscript.

hf_upload_commands.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# Upload ultrams_msnlib_benchmark_v1 to Hugging Face.
+#
+# THIS SCRIPT HAS NOT BEEN EXECUTED for this package. It is a reviewed command draft:
+# every command is printed first, and nothing is uploaded unless you pass --execute.
+#
+#   ./hf_upload_commands.sh                # print the commands and the pre-flight checklist
+#   ./hf_upload_commands.sh --gz-only      # same, but upload only the *.csv.gz tables
+#   ./hf_upload_commands.sh --execute      # actually run them (requires HF_TOKEN in the env)
+#
+# Managed files: every file of this manifest (~185 MiB, including the compact retention-time
+# table split_A_full_msnlib/msnlib_rt.csv.gz), plus two large source files that
+# are hosted alongside it because the split tables point into them:
+#   MSnLib.csv              752,707,651 B  sha256 be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07
+#   MSnLib_candidates.json  1,368,264,026 B sha256 125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc
+# Set MSNLIB_DATA_DIR to the directory that contains those two files (or override the two
+# individual paths).
+#
+# Prerequisites (not installed by this script):
+#   python -m pip install -U "huggingface_hub[cli]"
+#   export HF_TOKEN=...            # never commit a token, never paste one into this repo
+set -euo pipefail
+
+PKG_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+REPO_TYPE="dataset"
+# Dataset id placeholder agreed for the UltraMS MSnLib benchmark.
+REPO_ID="${HF_DATASET_REPO_ID:-dsadd4/UltraMS-MSnLib-Benchmark}"
+VISIBILITY="${HF_DATASET_VISIBILITY:-public}"
+COMMIT_MESSAGE="UltraMS MSnLib benchmark v1.0.0 (formula-level split A + strict-adduct molecule-level split B)"
+# Large hosted files (not part of this manifest).
+DATA_DIR="${MSNLIB_DATA_DIR:-/path/to/data-workspace/datasets/MSnLib}"
+MSNLIB_CSV="${MSNLIB_CSV:-$DATA_DIR/MSnLib.csv}"
+MSNLIB_CANDIDATES="${MSNLIB_CANDIDATES:-$DATA_DIR/MSnLib_candidates.json}"
+MSNLIB_CSV_SHA256="be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07"
+MSNLIB_CANDIDATES_SHA256="125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc"
+
+GZ_ONLY=0
+EXECUTE=0
+for arg in "$@"; do
+  case "$arg" in
+    --gz-only) GZ_ONLY=1 ;;
+    --execute) EXECUTE=1 ;;
+    -h|--help)
+      sed -n '2,17p' "${BASH_SOURCE[0]}"
+      exit 0
+      ;;
+    *)
+      echo "unknown argument: $arg" >&2
+      exit 2
+      ;;
+  esac
+done
+
+UPLOAD_ARGS=("$REPO_ID" "$PKG_DIR" --repo-type "$REPO_TYPE" --commit-message "$COMMIT_MESSAGE")
+if [[ "$GZ_ONLY" == 1 ]]; then
+  # skip the plain CSV copies and the local-only bookkeeping files
+  UPLOAD_ARGS+=(--exclude "*.csv" --exclude ".DS_Store")
+fi
+
+echo "package : $PKG_DIR"
+echo "repo    : $REPO_ID (type=$REPO_TYPE, visibility=$VISIBILITY)"
+echo "mode    : $([[ $GZ_ONLY == 1 ]] && echo '*.csv.gz + docs + protocol only' || echo 'everything')"
+echo "large   : $MSNLIB_CSV (752,707,651 B)"
+echo "          $MSNLIB_CANDIDATES (1,368,264,026 B)"
+echo
+echo "--- pre-flight checklist (all must be true before uploading) ---"
+cat <<'CHECKLIST'
+[ ] 1. shasum -a 256 -c SHA256SUMS (macOS) or sha256sum -c SHA256SUMS (Linux)
+       reports OK for every file.
+[ ] 2. python3 rebuild/verify_release.py exits 0 with every check PASS and no FAIL.
+[ ] 3. No retired legacy project naming:  grep -rni "<retired project name>" . | wc -l  -> 0
+       (the verifier checks this automatically; do not create files that reintroduce it).
+[ ] 4. No internal absolute paths from the build environment (data-preparation
+       workspaces, cluster scratch directories, user home directories) and no password/token value
+       is present in any file; the verifier checks this automatically.
+[ ] 5. Human sign-off on: dataset id (dsadd4/UltraMS-MSnLib-Benchmark), visibility, author
+       list in hf_dataset_card.md, license (CC BY 4.0) and the MSnLib attribution in NOTICE.md.
+[ ] 6. HF_TOKEN is exported in the current shell only (never written to disk).
+[ ] 7. Total upload size is understood: ~185 MiB manifest (+ ~24 MiB with --gz-only instead
+       of the plain CSVs) plus 752,707,651 B MSnLib.csv and 1,368,264,026 B
+       MSnLib_candidates.json (≈ 2.1 GiB in total).
+[ ] 8. The two large hosted files are checked before upload:
+       sha256sum "$MSNLIB_CSV"           -> be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07
+       sha256sum "$MSNLIB_CANDIDATES"    -> 125a1cdcc57a3fcef8cc76d5322ac0c434cd09b0bfb9e0c9d28bddf052f45fcc
+[ ] 9. The dataset card upload must refresh hf_dataset_card.md as the card (YAML header first).
+CHECKLIST
+echo
+echo "--- commands ---"
+cat <<EOF
+hf auth whoami
+hf auth login --token "\$HF_TOKEN"      # or: python -m huggingface_hub.commands.huggingface_cli login
+hf repo create "$REPO_ID" --repo-type "$REPO_TYPE" --$VISIBILITY
+# 1) the manifest (splits, protocol, rebuild scripts, docs; no spectra)
+hf upload ${UPLOAD_ARGS[*]}
+# 2) the large hosted source files (separate step; ~2.1 GiB of data)
+hf upload "$REPO_ID" "$MSNLIB_CSV" "MSnLib.csv" --repo-type "$REPO_TYPE" --commit-message "$COMMIT_MESSAGE"
+hf upload "$REPO_ID" "$MSNLIB_CANDIDATES" "MSnLib_candidates.json" --repo-type "$REPO_TYPE" --commit-message "$COMMIT_MESSAGE"
+EOF
+echo
+echo "--- post-upload ---"
+cat <<'EOF'
+Refresh the dataset card from hf_dataset_card.md (the YAML header must stay at the top),
+then verify the remote file list and sizes against SHA256SUMS, and finally re-download one
+table (both a split-A and a split-B table) and compare its SHA-256 with the local copy.
+Nothing in this repository is required for that check.
+EOF
+
+if [[ "$EXECUTE" != 1 ]]; then
+  echo
+  echo "dry run: nothing uploaded. Re-run with --execute once the checklist is signed off."
+  exit 0
+fi
+
+: "${HF_TOKEN:?set HF_TOKEN in the environment before using --execute}"
+command -v hf >/dev/null || {
+  echo "the 'hf' CLI is not installed: python -m pip install -U 'huggingface_hub[cli]'" >&2
+  exit 1
+}
+
+: "${MSNLIB_CSV:?set MSNLIB_DATA_DIR or MSNLIB_CSV to the MSnLib.csv path}"
+: "${MSNLIB_CANDIDATES:?set MSNLIB_DATA_DIR or MSNLIB_CANDIDATES to the MSnLib_candidates.json path}"
+set -x
+hf auth login --token "$HF_TOKEN"
+hf repo create "$REPO_ID" --repo-type "$REPO_TYPE" "--$VISIBILITY" || true
+hf upload "${UPLOAD_ARGS[@]}"
+hf upload "$REPO_ID" "$MSNLIB_CSV" "MSnLib.csv" --repo-type "$REPO_TYPE" --commit-message "$COMMIT_MESSAGE"
+hf upload "$REPO_ID" "$MSNLIB_CANDIDATES" "MSnLib_candidates.json" --repo-type "$REPO_TYPE" --commit-message "$COMMIT_MESSAGE"
+set +x
+echo "upload finished; verify the remote tree and checksums before announcing the release."

libraries/neg_test_library.csv

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

libraries/neg_test_library.csv.gz

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

libraries/neg_val_library.csv

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

libraries/neg_val_library.csv.gz

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

libraries/pos_test_library.csv

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

libraries/pos_test_library.csv.gz

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

libraries/pos_val_library.csv

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

libraries/pos_val_library.csv.gz

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

protocol/README.md

@@ -0,0 +1,75 @@
+# Frozen protocol files
+
+These files are the authoritative definition of the benchmark. The CSV tables in
+`splits/`, `queries/` and `libraries/` are a human-readable view of them; if the two ever
+disagree, the protocol files win.
+
+## Files
+
+| file | content |
+| --- | --- |
+| `manifest_summary.json` | the frozen manifest of the historical Figure 3h producer: counts, seeds, per-split sizes, ordered-SMILES and source-row SHA-256 values, vocabulary sizes, artifact hashes, input CSV/h5 hashes |
+| `protocol_pos.npz` | row-index arrays of the `[M+H]+` task |
+| `protocol_neg.npz` | row-index arrays of the `[M-H]-` task |
+| `smiles_pos.json` | list of canonical isomeric SMILES of the 41,348 positive compounds; a row's compound is `smiles_pos.json[smiles_index]` |
+| `smiles_neg.json` | same for the 21,293 negative compounds |
+| `adducts_pos.json`, `adducts_neg.json` | `["[M+H]+"]`, `["[M-H]-"]` — the strict adduct of each task |
+| `derived/row_metadata_pos.npz`, `derived/row_metadata_neg.npz` | per-preprocessed-row metadata extracted from the (not redistributed) preprocessed-spectra HDF5 file |
+
+## `protocol_*.npz` arrays
+
+Each archive has five 1-D `int64` arrays. Their indices are **frozen preprocessed row
+ids**: `0 … 301,635` for `pos`, `0 … 140,192` for `neg`. Row ids follow the source order of
+`MSnLib.csv` after the strict-adduct filter and the peak preprocessing; `derived/row_metadata_*.npz`
+maps them to `MSnLib.csv` data rows.
+
+| array | content | length (`pos` / `neg`) |
+| --- | --- | --- |
+| `train_rows` | training spectra, ordered "sorted train compound, then source order" | 211,745 / 98,401 |
+| `val_query_rows` | the validation queries, ordered by sorted validation compound | 6,202 / 3,193 |
+| `val_library_rows` | validation library, canonical-compound insertion order minus the validation queries | 250,424 / 116,135 |
+| `test_query_rows` | the test queries, ordered by sorted test compound | 6,202 / 3,193 |
+| `test_library_rows` | test library, canonical-compound insertion order minus the test queries | 295,434 / 137,000 |
+
+Invariants (all checked by `rebuild/verify_release.py`):
+
+* `test_query_rows` and `test_library_rows` are disjoint and together are exactly
+  `0 … N-1`: the test library is every preprocessed spectrum of the polarity minus the
+  selected test queries.
+* `val_query_rows` and `val_library_rows` are disjoint and only contain compounds of the
+  train or validation fold; test compounds never appear in the validation task.
+* The compound sets behind `train_rows`, `val_query_rows` and `test_query_rows` are the
+  pairwise-disjoint train / validation / test compound sets.
+
+## `derived/row_metadata_*.npz` arrays
+
+| array | dtype | meaning |
+| --- | --- | --- |
+| `source_row` | int64 | 0-based data row in `MSnLib.csv` (physical line = `source_row + 2`) |
+| `smiles_index` | int32 | index into `smiles_*.json` |
+| `adduct_index` | int16 | index into `adducts_*.json` (always 0 here) |
+| `n_peaks` | uint16 | peaks kept by the preprocessing (≤ 150) |
+| `precursor_mz` | float32 | precursor m/z as stored by the frozen protocol |
+
+These arrays are *derived* from the historical preprocessed-spectra file and are not part
+of the original manifest; they are included so that the package can be joined back to
+`MSnLib.csv` and to the row-index arrays without that file. Their hashes are in
+`../SHA256SUMS` like every other file.
+
+## `manifest_summary.json` redaction
+
+The frozen file recorded the absolute path of the original data-preparation workspace in
+its `csv` field. The released copy replaces only that string with
+`<original data-preparation workspace>/datasets/MSnLib/MSnLib.csv`; every count, seed, hash
+and identity field is byte-identical. Original file SHA-256
+`b83656b2b4d265d1d4ea49df30372e844e207863a7ab768f44f241bd68b8186e`; released copy SHA-256
+`6129ed094df59265a684f436da146ef554d9c774e01768363bf58704f87ec237`. See `../VERIFY.md`.
+
+## Ordered-list hashes
+
+`ordered_query_smiles_sha256`, `ordered_library_smiles_sha256` (validation and test),
+`query_source_row_sha256` and `library_source_row_sha256` (test) are SHA-256 digests of the
+corresponding sequence joined with `"\n"` (no trailing newline), computed over the strings
+in frozen order. They can be recomputed directly from the CSV tables — see
+`rebuild/verify_release.py`, which does exactly that and compares against
+`manifest_summary.json`.

protocol/adducts_neg.json

@@ -0,0 +1,3 @@
+[
+  "[M-H]-"
+]

protocol/adducts_pos.json

@@ -0,0 +1,3 @@
+[
+  "[M+H]+"
+]

protocol/derived/row_metadata_neg.npz

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

protocol/derived/row_metadata_pos.npz

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

protocol/manifest_summary.json

@@ -0,0 +1,126 @@
+{
+  "adduct_sets": {
+    "neg": [
+      "[M-H]-"
+    ],
+    "pos": [
+      "[M+H]+"
+    ]
+  },
+  "compound_identity": "RDKit canonical isomeric SMILES",
+  "csv": "<original data-preparation workspace>/datasets/MSnLib/MSnLib.csv",
+  "csv_sha256": "be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07",
+  "h5": {
+    "bytes": 110091598,
+    "path": "train/output/comparison/fig3_simple_baselines_20260821/fig3h_manifest_strict_adduct_v4/msnlib_fig3h_spectra.h5",
+    "sha256": "9296d42e060e7019604e16b20ba80ae13128e03b3e8ee912ee2efeb60bafdf59"
+  },
+  "mode_labels": {
+    "neg": "[M-H]-",
+    "pos": "[M+H]+"
+  },
+  "modes": {
+    "neg": {
+      "artifacts": {
+        "adducts_neg.json": {
+          "sha256": "6d2086ae948fe762ee80695f8f04505516b1259bd9c5ce3719ff47fa951622b5"
+        },
+        "protocol_neg.npz": {
+          "sha256": "7183fca678aa0f97dffdc6f4d4719ac993ca97592e0a468680893d0c0f3741db"
+        },
+        "smiles_neg.json": {
+          "sha256": "15a4ed45dd55ef27d05ad7a0a14ffcaa9a86e62f5f2120a18c358f748a98b989"
+        }
+      },
+      "invalid_rows": 4054,
+      "query_seed": 119,
+      "raw_adduct_rows": 144247,
+      "singleton_compounds_retained": 202,
+      "split_compound_counts": {
+        "test": 3193,
+        "train": 14907,
+        "val": 3193
+      },
+      "split_seed": 43,
+      "test": {
+        "library_source_row_sha256": "99b8d480087a6e90a17cfa8d0653e785285fce1e60cfd3596b4d1cf6d5ca97a4",
+        "n_library": 137000,
+        "n_queries_with_library_positive": 3160,
+        "n_query": 3193,
+        "ordered_library_smiles_sha256": "00dd373d9e175b070c2bd39595ee9532fdbd94f02a344897e81480e4b7784bc2",
+        "ordered_query_smiles_sha256": "db0aa2c39a1e5bc3c4463f97166c9d3e3ac150cba323f44bd29b636ccbd6553b",
+        "query_source_row_sha256": "2c9e896b1a267295882f6658ad664d6aab1648c37c7d02dfe98248fab69c42c8"
+      },
+      "train_spectra": 98401,
+      "valid_compounds": 21293,
+      "valid_preprocessed_rows_before_singleton_filter": 140193,
+      "validation": {
+        "library_scope": "train and validation compounds only; selected validation query excluded",
+        "n_library": 116135,
+        "n_query": 3193,
+        "ordered_library_smiles_sha256": "3fb782c8fbad923500cc392c5a080ad0718969519b5f69ae63adde0563cd955a",
+        "ordered_query_smiles_sha256": "3000c6a8bd24ae9dd082706d0ef3bcbd40939e1040f5ffe704a9923665f88412"
+      },
+      "vocabulary": {
+        "adducts": [
+          "[M-H]-"
+        ],
+        "n_adducts": 1,
+        "n_smiles": 21293
+      }
+    },
+    "pos": {
+      "artifacts": {
+        "adducts_pos.json": {
+          "sha256": "cafcaae472d3dda2337afb48801e37d9f3a318f5bcfcc9ca013f61815066ccd0"
+        },
+        "protocol_pos.npz": {
+          "sha256": "51a4a10ee4752b3e9bacd08084ec50a802aa4d852c5d599295fd62d99155f537"
+        },
+        "smiles_pos.json": {
+          "sha256": "bd4514be073297afd51ad3700661d0a15b2a223b1ebffd449a6a1f4084be6b8f"
+        }
+      },
+      "invalid_rows": 2073,
+      "query_seed": 119,
+      "raw_adduct_rows": 303709,
+      "singleton_compounds_retained": 39,
+      "split_compound_counts": {
+        "test": 6202,
+        "train": 28944,
+        "val": 6202
+      },
+      "split_seed": 42,
+      "test": {
+        "library_source_row_sha256": "044dc90f6ff8a69a847b9a289a9225a701a907be84d5a14d854e732c9423e0d0",
+        "n_library": 295434,
+        "n_queries_with_library_positive": 6201,
+        "n_query": 6202,
+        "ordered_library_smiles_sha256": "4d69c6f65f8c3ed84df54fc2aa6addd7b28fd1c28909386f4e4ced88d31aacce",
+        "ordered_query_smiles_sha256": "356f355727380d1df02abbb0aaa3391b180a5c7b93b2103058ba54e8dfae51f0",
+        "query_source_row_sha256": "6dd85e3f3ab28de89b5b3363314a7d84810cf7a53853e150e2160a712610bf9e"
+      },
+      "train_spectra": 211745,
+      "valid_compounds": 41348,
+      "valid_preprocessed_rows_before_singleton_filter": 301636,
+      "validation": {
+        "library_scope": "train and validation compounds only; selected validation query excluded",
+        "n_library": 250424,
+        "n_query": 6202,
+        "ordered_library_smiles_sha256": "fd4c3083f8930973ca7f1439284b5cec5dff35f4167f1d9da386ca26599b5500",
+        "ordered_query_smiles_sha256": "39ead3a4ce7f7bed717167cea96f5c929abacae13787db8dd018eb775cd74339"
+      },
+      "vocabulary": {
+        "adducts": [
+          "[M+H]+"
+        ],
+        "n_adducts": 1,
+        "n_smiles": 41348
+      }
+    }
+  },
+  "query_seed": 119,
+  "runtime_seconds": 144.18453192710876,
+  "split_seed": 42,
+  "status": "complete"
+}

protocol/protocol_neg.npz

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

protocol/protocol_pos.npz

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

queries/neg_test_queries.csv.gz

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

queries/neg_val_queries.csv.gz

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

queries/pos_test_queries.csv.gz

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

queries/pos_val_queries.csv.gz

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

rebuild/LICENSE-APACHE-2.0.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rebuild/README.md

@@ -0,0 +1,103 @@
+# Rebuilding the frozen artifacts, and verifying this package
+
+This directory contains the split-B producer and the package verifier. The split-A replay
+script is shipped next to the split-A tables:
+[`../split_A_full_msnlib/build_split_a.py`](../split_A_full_msnlib/build_split_a.py).
+
+## `verify_release.py` — no external data needed
+
+```bash
+python3 rebuild/verify_release.py
+```
+
+Runs a self-consistency check over the files shipped here (Python ≥ 3.10 + NumPy, no
+network, no MSnLib download):
+
+* split B: counts against `protocol/manifest_summary.json`, ordered SMILES and source-row
+  hashes recomputed from the CSV tables, compound-level disjointness, query↔library row
+  disjointness, the test partition, per-query library positives, the table ↔
+  `protocol_*.npz` row-id mapping, the frozen column schemas;
+* split A: formula-level uniqueness, the 21,107 / 16,885 / 2,110 / 2,112 and
+  446,667 / 55,980 / 57,437 counts, `row_formula_fold` ↔ `formula_split` agreement, the
+  test/validation row-index sequences, and both voting tables reproduced from
+  `test_spectra.csv`;
+* cross-split A × B: compound-level, spectra-level and row-level cross-tabulations, the
+  split-A test-fold overlap, and the single-formula-per-split-B-compound property;
+* release integrity: every `.csv`/`.csv.gz` twin, `stats.json` file sizes and hashes,
+  `SHA256SUMS`, and the absence of retired legacy naming, internal absolute paths and
+  private keys in the shipped text files.
+
+It exits non-zero on any failure. The transcript is in `../VERIFY.md`.
+
+## `build_library_manifest.py` — full replay of split B from MSnLib.csv
+
+These two scripts are byte-identical copies of the producer used by the UltraMS public
+release (`benchmarks/molecular_identification/source_code/original/build_library_manifest.py`
+and `baseline_common.py`; Apache-2.0, see `LICENSE-APACHE-2.0.txt`):
+
+| file | SHA-256 |
+| --- | --- |
+| `build_library_manifest.py` | `969760ce3a1a1f85e7bcd3e2b9c9c042675624e6df6940ee6a79a124877930e3` |
+| `baseline_common.py` | `72969bc51f39dc8ae044ebaf47cdd3546f90b32edfc2b467c356b10ff0232000` |
+
+Requirements: `numpy`, `h5py`, `rdkit`. The script writes a ~110 MB HDF5 cache of the
+preprocessed spectra plus the protocol artifacts.
+
+```bash
+# 1) obtain MSnLib.csv (see ../README.md §8); verify its SHA-256:
+#    be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07
+
+# 2) replay
+python build_library_manifest.py \
+  --csv  /path/to/workspace/datasets/MSnLib/MSnLib.csv \
+  --skip-reference-regression \
+  --output-dir /path/to/workspace/manifest_replay \
+  --split-seed 42 --query-seed 119
+
+# 3) compare with the frozen copies shipped here
+cd /path/to/workspace/manifest_replay
+sha256sum protocol_pos.npz protocol_neg.npz smiles_pos.json smiles_neg.json \
+          adducts_pos.json adducts_neg.json
+```
+
+Expected artifact hashes (from `protocol/manifest_summary.json`):
+
+| artifact | SHA-256 |
+| --- | --- |
+| `protocol_pos.npz` | `51a4a10ee4752b3e9bacd08084ec50a802aa4d852c5d599295fd62d99155f537` |
+| `protocol_neg.npz` | `7183fca678aa0f97dffdc6f4d4719ac993ca97592e0a468680893d0c0f3741db` |
+| `smiles_pos.json` | `bd4514be073297afd51ad3700661d0a15b2a223b1ebffd449a6a1f4084be6b8f` |
+| `smiles_neg.json` | `15a4ed45dd55ef27d05ad7a0a14ffcaa9a86e62f5f2120a18c358f748a98b989` |
+| `adducts_pos.json` | `cafcaae472d3dda2337afb48801e37d9f3a318f5bcfcc9ca013f61815066ccd0` |
+| `adducts_neg.json` | `6d2086ae948fe762ee80695f8f04505516b1259bd9c5ce3719ff47fa951622b5` |
+
+Notes:
+
+* The negative task uses `--split-seed 42 + 1 = 43` internally; this is not a CLI flag.
+* `--skip-reference-regression` skips the comparison against the historical embedding
+  SMILES files (they are not in this package). Without the flag you must also pass
+  `--reference-embedding-dir`.
+* The regenerated `manifest_summary.json` records the absolute paths of *your* machine and
+  therefore differs textually from the shipped copy (which has one path field redacted).
+  Compare the `modes` subtree and the artifact hashes, not the whole file.
+* The regenerated HDF5 file must have SHA-256
+  `9296d42e060e7019604e16b20ba80ae13128e03b3e8ee912ee2efeb60bafdf59` when built with the
+  same `MSnLib.csv`, RDKit runtime and h5py compression defaults.
+
+## Rebuilding split A
+
+```bash
+python3 split_A_full_msnlib/build_split_a.py --csv /path/to/MSnLib.csv
+python3 split_A_full_msnlib/build_split_a.py --csv /path/to/MSnLib.csv --output-dir replay_split_a
+```
+
+The first form is a read-only replay and hash check, the second writes the six split-A
+tables. RDKit 2026.03.5 is required for byte-identical canonical SMILES strings.
+
+## Chaining the split-B replay back to the CSV tables
+
+`build_library_manifest.py` only writes row indices. To regenerate the split-B tables in
+`splits/`, `queries/` and `libraries/`, join `protocol/*.npz` through
+`derived/row_metadata_*.npz` (`source_row` → `MSnLib.csv` row) and `smiles_*.json`
+(`smiles_index` → compound); `verify_release.py` documents the join it checks, and the
+schema is described in `../README.md` §5.2 and `../protocol/README.md`.

rebuild/baseline_common.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""Shared, audit-oriented utilities for the Figure 3 simple baselines."""
+
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+import math
+import os
+import random
+import tempfile
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Iterable, Sequence
+
+import numpy as np
+
+
+POSITIVE_ADDUCTS = frozenset(
+    {"[M+H]+", "[M+Na]+", "[M+NH4]+", "[M+K]+", "[M+H-H2O]+"}
+)
+NEGATIVE_ADDUCTS = frozenset(
+    {"[M-H]-", "[M+Cl]-", "[M+FA]-", "[M+FA-H]-", "[M+CH3COO]-"}
+)
+FOLD_TO_CODE = {"train": 0, "val": 1, "test": 2}
+CODE_TO_FOLD = {v: k for k, v in FOLD_TO_CODE.items()}
+
+
+def sha256_file(path: str | os.PathLike[str], block_size: int = 16 << 20) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        while True:
+            block = handle.read(block_size)
+            if not block:
+                break
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def sha256_lines(values: Iterable[str]) -> str:
+    digest = hashlib.sha256()
+    first = True
+    for value in values:
+        if not first:
+            digest.update(b"\n")
+        digest.update(str(value).encode("utf-8"))
+        first = False
+    return digest.hexdigest()
+
+
+def stable_uint32(text: str, base_seed: int = 0) -> int:
+    payload = f"{base_seed}\0{text}".encode("utf-8")
+    return int.from_bytes(hashlib.sha256(payload).digest()[:4], "big")
+
+
+def atomic_write_json(path: str | os.PathLike[str], payload: object) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile("w", dir=path.parent, delete=False) as handle:
+        json.dump(payload, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+        temporary = Path(handle.name)
+    os.replace(temporary, path)
+
+
+def parse_peak_strings(mzs_text: object, intensities_text: object) -> tuple[np.ndarray, np.ndarray]:
+    mzs = np.fromstring(str(mzs_text), dtype=np.float32, sep=",")
+    intensities = np.fromstring(str(intensities_text), dtype=np.float32, sep=",")
+    n = min(mzs.size, intensities.size)
+    if n == 0:
+        return np.empty(0, np.float32), np.empty(0, np.float32)
+    mzs = mzs[:n]
+    intensities = intensities[:n]
+    valid = np.isfinite(mzs) & np.isfinite(intensities) & (mzs > 0) & (intensities >= 0)
+    return mzs[valid], intensities[valid]
+
+
+def fingerprint_ffn_bins(
+    mzs: np.ndarray,
+    intensities: np.ndarray,
+    *,
+    max_mz: int = 1005,
+    bin_width: float = 1.0,
+) -> np.ndarray:
+    """MassSpecGym-style sum binning followed by maximum normalization."""
+    n_bins = int(math.ceil(max_mz / bin_width))
+    out = np.zeros(n_bins, dtype=np.float32)
+    if mzs.size == 0:
+        return out
+    idx = np.floor(mzs / bin_width).astype(np.int64)
+    keep = (idx >= 0) & (idx < n_bins) & (intensities > 0)
+    if keep.any():
+        np.add.at(out, idx[keep], intensities[keep])
+        maximum = float(out.max())
+        if maximum > 0:
+            out /= maximum
+    return out
+
+
+def raw_binned_sparse_row(
+    mzs: np.ndarray,
+    intensities: np.ndarray,
+    *,
+    max_peaks: int = 150,
+    bin_width: float = 0.02,
+    max_mz: float | None = None,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return sorted sparse indices/values for the frozen raw-cosine protocol."""
+    if mzs.size < 3 or intensities.size < 3:
+        return np.empty(0, np.int32), np.empty(0, np.float32)
+    maximum = float(intensities.max(initial=0.0))
+    if maximum <= 0:
+        return np.empty(0, np.int32), np.empty(0, np.float32)
+    scaled = np.clip(intensities / maximum, 0.0, 1.0)
+    if mzs.size > max_peaks:
+        chosen = np.argpartition(scaled, -max_peaks)[-max_peaks:]
+        mzs = mzs[chosen]
+        scaled = scaled[chosen]
+    idx = np.rint(mzs / bin_width).astype(np.int64)
+    keep = (idx >= 0) & (scaled > 0)
+    if max_mz is not None:
+        keep &= idx < int(math.ceil(max_mz / bin_width))
+    idx = idx[keep]
+    vals = np.sqrt(scaled[keep], dtype=np.float32)
+    if idx.size == 0:
+        return np.empty(0, np.int32), np.empty(0, np.float32)
+    order = np.argsort(idx, kind="stable")
+    idx, vals = idx[order], vals[order]
+    unique_idx, first = np.unique(idx, return_index=True)
+    summed = np.add.reduceat(vals, first).astype(np.float32, copy=False)
+    norm = float(np.linalg.norm(summed))
+    if norm > 0:
+        summed /= norm
+    return unique_idx.astype(np.int32, copy=False), summed
+
+
+def exact_tie_aware_fdr_curve(
+    top1_score: Sequence[float],
+    top1_correct: Sequence[bool],
+    *,
+    denominator: int,
+    min_hits: int = 10,
+) -> dict[str, np.ndarray]:
+    """Accept equal-score observations as one block and sweep every observed score."""
+    scores = np.asarray(top1_score, dtype=np.float64)
+    correct = np.asarray(top1_correct, dtype=bool)
+    if scores.ndim != 1 or scores.shape != correct.shape:
+        raise ValueError("score/correct arrays must be aligned one-dimensional arrays")
+    if denominator <= 0:
+        raise ValueError("recall denominator must be positive")
+    finite = np.isfinite(scores)
+    scores, correct = scores[finite], correct[finite]
+    order = np.argsort(-scores, kind="stable")
+    scores, correct = scores[order], correct[order]
+    if scores.size == 0:
+        empty = np.empty(0, dtype=np.float64)
+        return {"threshold": empty, "accepted": empty.astype(np.int64), "correct": empty.astype(np.int64), "fdr": empty, "recall": empty}
+    block_end = np.r_[scores[1:] != scores[:-1], True]
+    accepted_all = np.arange(1, scores.size + 1, dtype=np.int64)
+    correct_all = np.cumsum(correct, dtype=np.int64)
+    accepted = accepted_all[block_end]
+    n_correct = correct_all[block_end]
+    thresholds = scores[block_end]
+    fdr = np.full(accepted.shape, np.nan, dtype=np.float64)
+    eligible = accepted >= int(min_hits)
+    fdr[eligible] = (accepted[eligible] - n_correct[eligible]) / accepted[eligible]
+    recall = n_correct.astype(np.float64) / float(denominator)
+    return {
+        "threshold": thresholds,
+        "accepted": accepted,
+        "correct": n_correct,
+        "fdr": fdr,
+        "recall": recall,
+    }
+
+
+def fdr_envelope(curve: dict[str, np.ndarray], *, maximum: float = 0.35, n_grid: int = 500) -> dict[str, np.ndarray]:
+    fdr = np.asarray(curve["fdr"], dtype=np.float64)
+    recall = np.asarray(curve["recall"], dtype=np.float64)
+    valid = np.isfinite(fdr)
+    grid = np.linspace(0.0, maximum, n_grid)
+    envelope = np.zeros_like(grid)
+    for idx, budget in enumerate(grid):
+        eligible = valid & (fdr <= budget)
+        if eligible.any():
+            envelope[idx] = recall[eligible].max()
+    return {"fdr_grid": grid, "recall_envelope": envelope}
+
+
+def fdr_working_point(curve: dict[str, np.ndarray], target: float = 0.05) -> dict[str, float | int | None]:
+    fdr = np.asarray(curve["fdr"], dtype=np.float64)
+    recall = np.asarray(curve["recall"], dtype=np.float64)
+    valid = np.isfinite(fdr) & (fdr <= target)
+    if not valid.any():
+        return {"threshold": None, "fdr": None, "recall": 0.0, "accepted": 0, "correct": 0}
+    candidates = np.where(valid)[0]
+    # Highest recall, then lower FDR, then stricter threshold.
+    best = sorted(candidates, key=lambda i: (-recall[i], fdr[i], -curve["threshold"][i]))[0]
+    return {
+        "threshold": float(curve["threshold"][best]),
+        "fdr": float(fdr[best]),
+        "recall": float(recall[best]),
+        "accepted": int(curve["accepted"][best]),
+        "correct": int(curve["correct"][best]),
+    }
+
+
+def threshold_metrics(
+    top1_score: Sequence[float],
+    top1_correct: Sequence[bool],
+    threshold: float,
+    *,
+    denominator: int,
+) -> dict[str, float | int]:
+    score = np.asarray(top1_score, dtype=np.float64)
+    correct = np.asarray(top1_correct, dtype=bool)
+    accepted = np.isfinite(score) & (score >= float(threshold))
+    n_accepted = int(accepted.sum())
+    n_correct = int((accepted & correct).sum())
+    return {
+        "threshold": float(threshold),
+        "accepted": n_accepted,
+        "correct": n_correct,
+        "coverage": n_accepted / len(score) if len(score) else 0.0,
+        "fdr": (n_accepted - n_correct) / n_accepted if n_accepted else float("nan"),
+        "recall": n_correct / denominator if denominator else 0.0,
+    }
+
+
+def rank_metrics(ranks: Sequence[int], ks: Sequence[int] = (1, 5, 10, 20)) -> dict[str, float | int]:
+    values = np.asarray(ranks, dtype=np.int64)
+    if values.ndim != 1 or values.size == 0 or (values < 1).any():
+        raise ValueError("ranks must be a nonempty vector of positive integers")
+    result: dict[str, float | int] = {"n_queries": int(values.size)}
+    for k in ks:
+        result[f"top{k}"] = float(np.mean(values <= k))
+    result["mrr"] = float(np.mean(1.0 / values))
+    result["median_rank"] = float(np.median(values))
+    return result
+
+
+def candidate_consensus(
+    top_candidates: Sequence[Sequence[str]],
+    top_scores: Sequence[Sequence[float]],
+    *,
+    depth: int = 50,
+) -> list[str]:
+    """Frozen hard-plurality ranking with normalized-Borda tie support."""
+    votes: Counter[str] = Counter()
+    support: defaultdict[str, float] = defaultdict(float)
+    for candidates, _scores in zip(top_candidates, top_scores):
+        row = list(candidates[:depth])
+        if row:
+            votes[row[0]] += 1
+        denom = max(1, len(row))
+        for rank0, candidate in enumerate(row):
+            support[candidate] += (denom - rank0) / denom
+    return sorted(support, key=lambda c: (-votes[c], -support[c], c))
+
+
+def bootstrap_cluster_delta(
+    baseline: Sequence[float],
+    comparator: Sequence[float],
+    cluster_ids: Sequence[str],
+    *,
+    n_bootstrap: int = 10_000,
+    seed: int = 20260821,
+) -> dict[str, object]:
+    """Paired cluster bootstrap of the mean comparator-minus-baseline difference."""
+    a = np.asarray(baseline, dtype=np.float64)
+    b = np.asarray(comparator, dtype=np.float64)
+    clusters = np.asarray(cluster_ids, dtype=object)
+    if a.shape != b.shape or a.shape != clusters.shape:
+        raise ValueError("paired arrays and cluster ids must align")
+    unique, inverse = np.unique(clusters, return_inverse=True)
+    cluster_sum = np.bincount(inverse, weights=b - a)
+    cluster_n = np.bincount(inverse)
+    rng = np.random.default_rng(seed)
+    draws = np.empty(n_bootstrap, dtype=np.float64)
+    for idx in range(n_bootstrap):
+        sampled = rng.integers(0, len(unique), size=len(unique))
+        draws[idx] = cluster_sum[sampled].sum() / cluster_n[sampled].sum()
+    return {
+        "estimate": float(np.mean(b - a)),
+        "ci_low": float(np.quantile(draws, 0.025)),
+        "ci_high": float(np.quantile(draws, 0.975)),
+        "n_clusters": int(len(unique)),
+        "n_observations": int(len(a)),
+        "n_bootstrap": int(n_bootstrap),
+        "seed": int(seed),
+        "draws": draws,
+    }
+
+
+def read_csv_rows(path: str | os.PathLike[str]) -> Iterable[dict[str, str]]:
+    with open(path, newline="") as handle:
+        yield from csv.DictReader(handle)
+
+
+def split_compounds(smiles: Sequence[str], *, seed: int = 42, val_ratio: float = 0.15, test_ratio: float = 0.15) -> dict[str, list[str]]:
+    ordered = sorted(smiles)
+    rng = random.Random(seed)
+    rng.shuffle(ordered)
+    n_test = int(len(ordered) * test_ratio)
+    n_val = int(len(ordered) * val_ratio)
+    return {
+        "test": ordered[:n_test],
+        "val": ordered[n_test : n_test + n_val],
+        "train": ordered[n_test + n_val :],
+    }
+
+
+def choose_query_row_ids(
+    row_ids_by_smiles: dict[str, list[int]],
+    compounds: Sequence[str],
+    *,
+    seed: int = 119,
+) -> tuple[list[int], list[str]]:
+    rng = random.Random(seed)
+    rows: list[int] = []
+    smiles: list[str] = []
+    for smi in sorted(compounds):
+        rows.append(rng.choice(row_ids_by_smiles[smi]))
+        smiles.append(smi)
+    return rows, smiles
+
+
+def build_library_row_ids(
+    row_ids_by_smiles: dict[str, list[int]],
+    excluded_query_rows: Sequence[int],
+    *,
+    allowed_compounds: set[str] | None = None,
+) -> tuple[list[int], list[str]]:
+    excluded = set(int(x) for x in excluded_query_rows)
+    rows: list[int] = []
+    smiles: list[str] = []
+    for smi in sorted(row_ids_by_smiles):
+        if allowed_compounds is not None and smi not in allowed_compounds:
+            continue
+        for row_id in row_ids_by_smiles[smi]:
+            if row_id not in excluded:
+                rows.append(row_id)
+                smiles.append(smi)
+    return rows, smiles

rebuild/build_library_manifest.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""Replay and freeze the exact Figure 3h query/library construction with source rows."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import h5py
+import numpy as np
+from rdkit import Chem
+
+from baseline_common import (
+    atomic_write_json,
+    read_csv_rows,
+    sha256_file,
+    sha256_lines,
+    split_compounds,
+)
+
+
+MODE_ADDUCT = {"pos": "[M+H]+", "neg": "[M-H]-"}
+
+
+def producer_preprocess(mzs_text: object, intensities_text: object, max_peaks: int = 150):
+    mz = np.fromstring(str(mzs_text), dtype=np.float32, sep=",")
+    intensity = np.fromstring(str(intensities_text), dtype=np.float32, sep=",")
+    n = min(len(mz), len(intensity))
+    mz, intensity = mz[:n], intensity[:n]
+    valid = mz > 0
+    mz, intensity = mz[valid], intensity[valid]
+    if len(mz) < 3:
+        return None
+    maximum = float(intensity.max())
+    if maximum <= 0:
+        return None
+    intensity = np.clip(intensity / maximum, 0, 1)
+    if len(mz) > max_peaks:
+        chosen = np.sort(np.argsort(intensity)[-max_peaks:])
+        mz, intensity = mz[chosen], intensity[chosen]
+    order = np.argsort(mz)
+    return np.stack([mz[order], intensity[order]], axis=-1).astype(np.float32)
+
+
+class ModeWriter:
+    def __init__(self, group: h5py.Group, mode: str, buffer_size: int = 5000) -> None:
+        self.mode = mode
+        self.buffer_size = buffer_size
+        self.spectra = group.create_dataset(
+            "spectra",
+            shape=(0, 150, 2),
+            maxshape=(None, 150, 2),
+            dtype="f4",
+            chunks=(256, 150, 2),
+            compression="lzf",
+        )
+        self.n_peaks = group.create_dataset(
+            "n_peaks", shape=(0,), maxshape=(None,), dtype="u2", chunks=True, compression="lzf"
+        )
+        self.source_row = group.create_dataset(
+            "source_row", shape=(0,), maxshape=(None,), dtype="i8", chunks=True, compression="lzf"
+        )
+        self.precursor_mz = group.create_dataset(
+            "precursor_mz", shape=(0,), maxshape=(None,), dtype="f4", chunks=True, compression="lzf"
+        )
+        self.smiles_index = group.create_dataset(
+            "smiles_index", shape=(0,), maxshape=(None,), dtype="i4", chunks=True, compression="lzf"
+        )
+        self.adduct_index = group.create_dataset(
+            "adduct_index", shape=(0,), maxshape=(None,), dtype="i2", chunks=True, compression="lzf"
+        )
+        self.smiles: list[str] = []
+        self.smiles_to_idx: dict[str, int] = {}
+        self.adducts: list[str] = []
+        self.adduct_to_idx: dict[str, int] = {}
+        self.row_ids_by_smiles: defaultdict[str, list[int]] = defaultdict(list)
+        self.buffer: list[tuple[np.ndarray, int, int, float, int, int]] = []
+        self.count = 0
+
+    def append(self, spectrum: np.ndarray, source_row: int, precursor_mz: float, smiles: str, adduct: str) -> None:
+        if smiles not in self.smiles_to_idx:
+            self.smiles_to_idx[smiles] = len(self.smiles)
+            self.smiles.append(smiles)
+        if adduct not in self.adduct_to_idx:
+            self.adduct_to_idx[adduct] = len(self.adducts)
+            self.adducts.append(adduct)
+        local_row = self.count + len(self.buffer)
+        self.row_ids_by_smiles[smiles].append(local_row)
+        padded = np.zeros((150, 2), dtype=np.float32)
+        padded[: len(spectrum)] = spectrum
+        self.buffer.append(
+            (
+                padded,
+                len(spectrum),
+                source_row,
+                precursor_mz,
+                self.smiles_to_idx[smiles],
+                self.adduct_to_idx[adduct],
+            )
+        )
+        if len(self.buffer) >= self.buffer_size:
+            self.flush()
+
+    def flush(self) -> None:
+        if not self.buffer:
+            return
+        start, end = self.count, self.count + len(self.buffer)
+        for dataset in (
+            self.spectra,
+            self.n_peaks,
+            self.source_row,
+            self.precursor_mz,
+            self.smiles_index,
+            self.adduct_index,
+        ):
+            dataset.resize((end,) + dataset.shape[1:])
+        self.spectra[start:end] = np.stack([row[0] for row in self.buffer])
+        self.n_peaks[start:end] = [row[1] for row in self.buffer]
+        self.source_row[start:end] = [row[2] for row in self.buffer]
+        self.precursor_mz[start:end] = [row[3] for row in self.buffer]
+        self.smiles_index[start:end] = [row[4] for row in self.buffer]
+        self.adduct_index[start:end] = [row[5] for row in self.buffer]
+        self.count = end
+        self.buffer.clear()
+
+
+def choose_queries(row_ids_by_smiles: dict[str, list[int]], compounds: list[str], seed: int) -> tuple[list[int], list[str]]:
+    rng = random.Random(seed)
+    rows, smiles = [], []
+    for smi in sorted(compounds):
+        rows.append(rng.choice(row_ids_by_smiles[smi]))
+        smiles.append(smi)
+    return rows, smiles
+
+
+def build_library(
+    row_ids_by_smiles: dict[str, list[int]],
+    excluded: list[int],
+    allowed: set[str] | None = None,
+) -> tuple[list[int], list[str]]:
+    excluded_set = set(excluded)
+    rows, smiles = [], []
+    # Historical producer retained canonical-compound insertion order from the
+    # source CSV.  This order is part of the frozen embedding/library identity.
+    for smi in row_ids_by_smiles:
+        if allowed is not None and smi not in allowed:
+            continue
+        for row_id in row_ids_by_smiles[smi]:
+            if row_id not in excluded_set:
+                rows.append(row_id)
+                smiles.append(smi)
+    return rows, smiles
+
+
+def build(args: argparse.Namespace) -> None:
+    out = Path(args.output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    h5_path = out / "msnlib_fig3h_spectra.h5"
+    if h5_path.exists() and not args.force:
+        raise FileExistsError(f"refusing to overwrite {h5_path}; use --force only for a fresh versioned run")
+    if h5_path.exists():
+        h5_path.unlink()
+    started = time.time()
+    raw_counts = {"pos": 0, "neg": 0}
+    invalid_counts = {"pos": 0, "neg": 0}
+    # The frozen Figure 3h producer used the two strict adduct subsets below.
+    # A newer fine-tuning script in the snapshot broadened these to composite
+    # ion-mode sets, but those sets do not reproduce the frozen embeddings.
+    mode_sets = {mode: {adduct} for mode, adduct in MODE_ADDUCT.items()}
+    with h5py.File(h5_path, "w") as h5:
+        writers = {mode: ModeWriter(h5.create_group(mode), mode) for mode in ("pos", "neg")}
+        for source_row, row in enumerate(read_csv_rows(args.csv)):
+            adduct = str(row.get("adduct", ""))
+            mode = "pos" if adduct == MODE_ADDUCT["pos"] else "neg" if adduct == MODE_ADDUCT["neg"] else None
+            if mode is None:
+                continue
+            raw_counts[mode] += 1
+            spectrum = producer_preprocess(row["mzs"], row["intensities"], max_peaks=150)
+            raw_smiles = str(row.get("smiles", "")).strip()
+            molecule = None if raw_smiles in ("", "nan") else Chem.MolFromSmiles(raw_smiles)
+            smiles = Chem.MolToSmiles(molecule, canonical=True) if molecule is not None else ""
+            if spectrum is None or not smiles:
+                invalid_counts[mode] += 1
+                continue
+            writers[mode].append(
+                spectrum,
+                source_row,
+                float(row["precursor_mz"]),
+                smiles,
+                adduct,
+            )
+            total = raw_counts["pos"] + raw_counts["neg"]
+            if total % 50_000 == 0:
+                print(f"eligible_rows_seen={total:,}", flush=True)
+        for writer in writers.values():
+            writer.flush()
+
+        summary: dict[str, object] = {
+            "status": "complete",
+            "csv": str(Path(args.csv).resolve()),
+            "csv_sha256": sha256_file(args.csv),
+            "split_seed": args.split_seed,
+            "query_seed": args.query_seed,
+            "mode_labels": {"pos": "[M+H]+", "neg": "[M-H]-"},
+            "compound_identity": "RDKit canonical isomeric SMILES",
+            "adduct_sets": {mode: sorted(values) for mode, values in mode_sets.items()},
+            "modes": {},
+        }
+        for mode, writer in writers.items():
+            # The historical producer split every valid canonical compound,
+            # including singletons.  A test singleton has no remaining library
+            # positive after its only spectrum becomes the query (1 positive,
+            # 33 negative in the frozen benchmark).
+            valid_rows = dict(writer.row_ids_by_smiles)
+            singleton_spectra = sum(len(rows) for rows in valid_rows.values() if len(rows) == 1)
+            mode_offset = 0 if mode == "pos" else 1
+            mode_split_seed = args.split_seed + mode_offset
+            mode_query_seed = args.query_seed
+            splits = split_compounds(list(valid_rows), seed=mode_split_seed)
+            test_query_rows, test_query_smis = choose_queries(valid_rows, splits["test"], mode_query_seed)
+            test_library_rows, test_library_smis = build_library(valid_rows, test_query_rows)
+            val_query_rows, val_query_smis = choose_queries(valid_rows, splits["val"], mode_query_seed)
+            val_allowed = set(splits["train"]) | set(splits["val"])
+            val_library_rows, val_library_smis = build_library(
+                valid_rows, val_query_rows, allowed=val_allowed
+            )
+            train_rows = [row for smi in sorted(splits["train"]) for row in valid_rows[smi]]
+
+            if not args.skip_reference_regression:
+                if not args.reference_embedding_dir:
+                    raise ValueError("--reference-embedding-dir is required for reference regression")
+                reference_dir = Path(args.reference_embedding_dir)
+                reference_query = json.loads(
+                    (reference_dir / f"emb_msnlib_{mode}_query_smis.json").read_text()
+                )
+                reference_library = json.loads(
+                    (reference_dir / f"emb_msnlib_{mode}_lib_smis.json").read_text()
+                )
+                if reference_query != test_query_smis:
+                    raise RuntimeError(f"{mode} replayed query SMILES differ from frozen reference")
+                if reference_library != test_library_smis:
+                    raise RuntimeError(f"{mode} replayed library SMILES differ from frozen reference")
+
+            smiles_path = out / f"smiles_{mode}.json"
+            adduct_path = out / f"adducts_{mode}.json"
+            atomic_write_json(smiles_path, writer.smiles)
+            atomic_write_json(adduct_path, writer.adducts)
+            protocol_path = out / f"protocol_{mode}.npz"
+            np.savez_compressed(
+                protocol_path,
+                train_rows=np.asarray(train_rows, dtype=np.int64),
+                val_query_rows=np.asarray(val_query_rows, dtype=np.int64),
+                val_library_rows=np.asarray(val_library_rows, dtype=np.int64),
+                test_query_rows=np.asarray(test_query_rows, dtype=np.int64),
+                test_library_rows=np.asarray(test_library_rows, dtype=np.int64),
+            )
+            library_counts = defaultdict(int)
+            for smi in test_library_smis:
+                library_counts[smi] += 1
+            n_eligible = sum(library_counts[smi] > 0 for smi in test_query_smis)
+            source_rows_array = np.asarray(writer.source_row)
+            mode_summary = {
+                "raw_adduct_rows": raw_counts[mode],
+                "invalid_rows": invalid_counts[mode],
+                "valid_preprocessed_rows_before_singleton_filter": writer.count,
+                "singleton_compounds_retained": singleton_spectra,
+                "valid_compounds": len(valid_rows),
+                "split_seed": mode_split_seed,
+                "query_seed": mode_query_seed,
+                "split_compound_counts": {key: len(value) for key, value in splits.items()},
+                "train_spectra": len(train_rows),
+                "validation": {
+                    "n_query": len(val_query_rows),
+                    "n_library": len(val_library_rows),
+                    "ordered_query_smiles_sha256": sha256_lines(val_query_smis),
+                    "ordered_library_smiles_sha256": sha256_lines(val_library_smis),
+                    "library_scope": "train and validation compounds only; selected validation query excluded",
+                },
+                "test": {
+                    "n_query": len(test_query_rows),
+                    "n_library": len(test_library_rows),
+                    "n_queries_with_library_positive": n_eligible,
+                    "ordered_query_smiles_sha256": sha256_lines(test_query_smis),
+                    "ordered_library_smiles_sha256": sha256_lines(test_library_smis),
+                    "query_source_row_sha256": sha256_lines(
+                        map(str, source_rows_array[np.asarray(test_query_rows)].tolist())
+                    ),
+                    "library_source_row_sha256": sha256_lines(
+                        map(str, source_rows_array[np.asarray(test_library_rows)].tolist())
+                    ),
+                },
+                "vocabulary": {
+                    "n_smiles": len(writer.smiles),
+                    "n_adducts": len(writer.adducts),
+                    "adducts": writer.adducts,
+                },
+                "artifacts": {
+                    protocol_path.name: {"sha256": sha256_file(protocol_path)},
+                    smiles_path.name: {"sha256": sha256_file(smiles_path)},
+                    adduct_path.name: {"sha256": sha256_file(adduct_path)},
+                },
+            }
+            summary["modes"][mode] = mode_summary
+
+    summary["h5"] = {
+        "path": str(h5_path),
+        "sha256": sha256_file(h5_path),
+        "bytes": h5_path.stat().st_size,
+    }
+    summary["runtime_seconds"] = time.time() - started
+    atomic_write_json(out / "manifest_summary.json", summary)
+    print(json.dumps(summary, indent=2), flush=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--csv", required=True)
+    parser.add_argument("--reference-embedding-dir")
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--split-seed", type=int, default=42)
+    parser.add_argument("--query-seed", type=int, default=119)
+    parser.add_argument("--skip-reference-regression", action="store_true")
+    parser.add_argument("--force", action="store_true")
+    args = parser.parse_args()
+    build(args)
+
+
+if __name__ == "__main__":
+    main()

rebuild/verify_release.py

@@ -0,0 +1,511 @@
+#!/usr/bin/env python3
+"""Self-contained verifier for ultrams_msnlib_benchmark_v1.
+
+Runs only on files shipped in this package (Python 3.10+, NumPy). It re-derives every
+published count, ordering hash, overlap statement and cross-split statistic from the CSV
+tables and the frozen protocol arrays, checks the checksums in SHA256SUMS, and exits
+non-zero if anything disagrees.
+
+    python3 rebuild/verify_release.py
+"""
+from __future__ import annotations
+
+import csv
+import gzip
+import hashlib
+import json
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import numpy as np
+
+PKG = Path(__file__).resolve().parent.parent
+MODES = ("pos", "neg")
+A_DIR = PKG / "split_A_full_msnlib"
+CHECKS: list[tuple[str, bool, str]] = []
+
+# Built as concatenations so that this verifier itself does not contain the strings it
+# forbids anywhere in the release.
+FORBIDDEN_NAMES = ("spec" + "bridge",)
+FORBIDDEN_PATH_TOKENS = (
+    "/hpc" + "2hdd/",
+    "/gem" + "ini/",
+    "/Us" + "ers/" + "yifanliscn",
+    "BEGIN RSA " + "PRIVATE KEY",
+    "BEGIN OPENSSH " + "PRIVATE KEY",
+    "yli" + "994",
+    "aims" + "lab",
+)
+
+A_EXPECTED = {
+    "n_formula": 21107,
+    "n_formula_train": 16885,
+    "n_formula_val": 2110,
+    "n_formula_test": 2112,
+    "n_spectra_train": 446667,
+    "n_spectra_val": 55980,
+    "n_spectra_test": 57437,
+    "n_spectra_total": 560084,
+    "n_test_spectra": 57437,
+    "n_val_spectra": 55980,
+    "n_voting_official": 5002,
+    "n_voting_official_spectra": 57436,
+    "n_voting_canonical": 4888,
+    "n_voting_canonical_spectra": 57436,
+}
+
+
+def check(name: str, ok: bool, detail: str = "") -> None:
+    CHECKS.append((name, bool(ok), detail))
+    print(f"[{'PASS' if ok else 'FAIL'}] {name}" + (f" :: {detail}" if detail else ""))
+
+
+def sha256_lines(values) -> str:
+    digest = hashlib.sha256()
+    first = True
+    for value in values:
+        if not first:
+            digest.update(b"\n")
+        digest.update(str(value).encode("utf-8"))
+        first = False
+    return digest.hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as fh:
+        while block := fh.read(8 << 20):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def read_csv(path: Path) -> list[dict[str, str]]:
+    with open(path, newline="", encoding="utf-8") as fh:
+        return list(csv.DictReader(fh))
+
+
+def main() -> int:
+    manifest = json.loads((PKG / "protocol/manifest_summary.json").read_text())
+    stats = json.loads((PKG / "stats.json").read_text())
+
+    # every shipped .csv must be byte-identical to its .csv.gz twin
+    mismatched = []
+    for plain in sorted(PKG.rglob("*.csv")):
+        gz = plain.with_suffix(plain.suffix + ".gz")
+        if not gz.exists():
+            mismatched.append(f"{plain.name}: missing .gz")
+            continue
+        if gzip.open(gz, "rb").read() != plain.read_bytes():
+            mismatched.append(plain.name)
+    check("csv.gz twins byte-identical to plain csv", not mismatched, ",".join(mismatched))
+
+    # ---------------------------------------------------------------- split B
+    for mode in MODES:
+        label = manifest["mode_labels"][mode]
+        adduct = manifest["adduct_sets"][mode][0]
+        m = manifest["modes"][mode]
+        meta = np.load(PKG / f"protocol/derived/row_metadata_{mode}.npz")
+        npz = np.load(PKG / f"protocol/protocol_{mode}.npz")
+        smiles = json.loads((PKG / f"protocol/smiles_{mode}.json").read_text())
+        adducts = json.loads((PKG / f"protocol/adducts_{mode}.json").read_text())
+        check(f"B/{mode}: protocol adduct vocabulary == {adduct}", adducts == [adduct], str(adducts))
+
+        src = meta["source_row"]
+        smi_idx = meta["smiles_index"]
+        row_smiles = [smiles[int(i)] for i in smi_idx]
+        src_to_row = {int(s): i for i, s in enumerate(src.tolist())}
+        check(f"B/{mode}: preprocessed row metadata covers all {len(src):,} rows uniquely",
+              len(src_to_row) == len(src) and int(src.max()) < 560084)
+
+        # ---- splits table ----
+        split_rows = read_csv(PKG / f"splits/{mode}_compound_split.csv")
+        split_of: dict[str, str] = {}
+        for row in split_rows:
+            split_of[row["canonical_isomeric_smiles"]] = row["split"]
+        counts = Counter(split_of.values())
+        check(f"B/{mode}: compound split counts match manifest",
+              dict(counts) == m["split_compound_counts"],
+              f"{dict(counts)} vs {m['split_compound_counts']}")
+        check(f"B/{mode}: compound vocabulary is exactly the frozen smiles vocabulary",
+              set(split_of) == set(smiles), f"{len(split_of)} vs {len(smiles)}")
+        check(f"B/{mode}: compound_ids unique",
+              len({r["compound_id"] for r in split_rows}) == len(split_rows))
+        n_spectra_sum = sum(int(r["n_spectra"]) for r in split_rows)
+        check(f"B/{mode}: spectra per compound sum to manifest valid rows",
+              n_spectra_sum == m["valid_preprocessed_rows_before_singleton_filter"],
+              f"{n_spectra_sum}")
+        check(f"B/{mode}: split table columns are the released schema",
+              list(split_rows[0]) == ["polarity", "compound_id", "canonical_isomeric_smiles", "split",
+                                      "n_spectra", "n_frozen_queries", "n_raw_smiles_variants",
+                                      "first_msnlib_csv_data_row"],
+              str(list(split_rows[0])))
+
+        # compound-level identity disjointness across the three folds
+        train_set = {s for s, v in split_of.items() if v == "train"}
+        val_set = {s for s, v in split_of.items() if v == "val"}
+        test_set = {s for s, v in split_of.items() if v == "test"}
+        check(f"B/{mode}: train/val/test compound sets pairwise disjoint",
+              not (train_set & val_set) and not (train_set & test_set) and not (val_set & test_set))
+        check(f"B/{mode}: the three compound sets cover the whole vocabulary",
+              len(train_set) + len(val_set) + len(test_set) == len(smiles))
+
+        # ---- queries / libraries ----
+        for split, manifest_key in (("val", "validation"), ("test", "test")):
+            q = read_csv(PKG / f"queries/{mode}_{split}_queries.csv")
+            lib = read_csv(PKG / f"libraries/{mode}_{split}_library.csv")
+            q_smiles = [r["canonical_isomeric_smiles"] for r in q]
+            l_smiles = [r["canonical_isomeric_smiles"] for r in lib]
+            q_src = [int(r["msnlib_csv_data_row"]) for r in q]
+            l_src = [int(r["msnlib_csv_data_row"]) for r in lib]
+            exp = m[manifest_key]
+
+            check(f"B/{mode}/{split}: query count {len(q):,} matches manifest",
+                  len(q) == exp["n_query"], f"{len(q)} vs {exp['n_query']}")
+            check(f"B/{mode}/{split}: library count {len(lib):,} matches manifest",
+                  len(lib) == exp["n_library"], f"{len(lib)} vs {exp['n_library']}")
+            check(f"B/{mode}/{split}: ordered query SMILES sha256 matches manifest",
+                  sha256_lines(q_smiles) == exp["ordered_query_smiles_sha256"])
+            check(f"B/{mode}/{split}: ordered library SMILES sha256 matches manifest",
+                  sha256_lines(l_smiles) == exp["ordered_library_smiles_sha256"])
+            check(f"B/{mode}/{split}: table row order == frozen query_index/library_index",
+                  [int(r["query_index"]) for r in q] == list(range(len(q)))
+                  and [int(r["library_index"]) for r in lib] == list(range(len(lib))))
+            check(f"B/{mode}/{split}: query rows and library rows are disjoint",
+                  not (set(q_src) & set(l_src)), f"{len(set(q_src) & set(l_src))} shared rows")
+            check(f"B/{mode}/{split}: queries are one spectrum per compound in this fold",
+                  sorted(q_smiles) == sorted(val_set if split == "val" else test_set))
+            check(f"B/{mode}/{split}: library compounds respect the fold scope",
+                  all(split_of[s] in ({"train", "val"} if split == "val" else {"train", "val", "test"})
+                      for s in l_smiles))
+            # tables <-> frozen protocol row ids
+            q_rows = npz[f"{split}_query_rows"]
+            l_rows = npz[f"{split}_library_rows"]
+            check(f"B/{mode}/{split}: query table maps to protocol_{mode}.npz query rows",
+                  [src_to_row[s] for s in q_src] == q_rows.tolist())
+            check(f"B/{mode}/{split}: library table maps to protocol_{mode}.npz library rows",
+                  [src_to_row[s] for s in l_src] == l_rows.tolist())
+            check(f"B/{mode}/{split}: source rows unique in each table",
+                  len(set(q_src)) == len(q_src) and len(set(l_src)) == len(l_src))
+            # per-query exact-adduct library positives
+            lib_counts = Counter(l_smiles)
+            recomputed = [lib_counts.get(s, 0) for s in q_smiles]
+            check(f"B/{mode}/{split}: n_library_positives column reproduces from the library table",
+                  recomputed == [int(r["n_library_positives"]) for r in q])
+            n_pos = sum(1 for c in recomputed if c > 0)
+            if split == "test":
+                check(f"B/{mode}/test: queries with an exact-adduct library positive == manifest ({exp['n_queries_with_library_positive']:,})",
+                      n_pos == exp["n_queries_with_library_positive"], f"{n_pos}")
+                check(f"B/{mode}/test: source-row hashes match manifest",
+                      sha256_lines(map(str, q_src)) == exp["query_source_row_sha256"]
+                      and sha256_lines(map(str, l_src)) == exp["library_source_row_sha256"])
+            else:
+                print(f"       ({mode}/val queries with a library positive: {n_pos:,} / {len(q):,})")
+            # adduct / fold / CE sanity
+            check(f"B/{mode}/{split}: adduct column is strict {adduct} everywhere",
+                  {r["adduct"] for r in q + lib} == {adduct})
+            check(f"B/{mode}/{split}: csv line = data row + 2 (header offset, no embedded newlines)",
+                  all(int(r["msnlib_csv_line"]) == int(r["msnlib_csv_data_row"]) + 2 for r in q + lib))
+            # precursor_mz and peak counts agree with the frozen row metadata
+            pmz_rows = [src_to_row[s] for s in q_src]
+            pmz_ok = all(
+                np.float32(float(r["precursor_mz"])) == np.float32(meta["precursor_mz"][row])
+                and int(r["n_peaks"]) == int(meta["n_peaks"][row])
+                for r, row in zip(q, pmz_rows)
+            )
+            check(f"B/{mode}/{split}: precursor_mz/n_peaks agree with frozen row metadata (queries)", pmz_ok)
+            check(f"B/{mode}/{split}: query/library table columns are the released schema",
+                  set(q[0]) == {"polarity", "split", "query_index", "compound_id", "canonical_isomeric_smiles",
+                                "adduct", "msnlib_csv_data_row", "msnlib_csv_line", "precursor_mz", "n_peaks",
+                                "collision_energy", "source_smiles_raw", "n_library_positives"}
+                  and set(lib[0]) == {"polarity", "split", "library_index", "compound_id", "compound_split",
+                                      "canonical_isomeric_smiles", "adduct", "msnlib_csv_data_row",
+                                      "msnlib_csv_line", "precursor_mz", "n_peaks", "collision_energy",
+                                      "source_smiles_raw"},
+                  "")
+
+        # partition: test library + test query rows cover every preprocessed row exactly once
+        tq = npz["test_query_rows"]
+        tl = npz["test_library_rows"]
+        check(f"B/{mode}: test queries + test library partition all preprocessed rows",
+              sorted(tq.tolist() + tl.tolist()) == list(range(len(src))))
+        # fold scope: train rows all belong to train compounds
+        check(f"B/{mode}: protocol train_rows all belong to train compounds",
+              all(split_of[row_smiles[i]] == "train" for i in npz["train_rows"].tolist()))
+        check(f"B/{mode}: protocol val_query_rows all belong to val compounds",
+              all(split_of[row_smiles[i]] == "val" for i in npz["val_query_rows"].tolist()))
+        check(f"B/{mode}: protocol test_query_rows all belong to test compounds",
+              all(split_of[row_smiles[i]] == "test" for i in npz["test_query_rows"].tolist()))
+
+        # recorded provenance of the source CSV
+        check(f"B/{mode}: source MSnLib.csv sha256 recorded",
+              manifest["csv_sha256"] == stats["source"]["msnlib_csv"]["sha256"])
+
+    # ---- cross-polarity relations recorded in stats ----
+    cross = stats["splits"]["B"]["cross_polarity"]
+    pos_test = {r["canonical_isomeric_smiles"] for r in read_csv(PKG / "splits/pos_compound_split.csv") if r["split"] == "test"}
+    neg_test = {r["canonical_isomeric_smiles"] for r in read_csv(PKG / "splits/neg_compound_split.csv") if r["split"] == "test"}
+    check("B: cross-polarity pos-test x neg-test intersection reproduces stats.json",
+          len(pos_test & neg_test) == cross["pos_test_intersect_neg_test"],
+          f"{len(pos_test & neg_test)} vs {cross['pos_test_intersect_neg_test']}")
+
+    # ---------------------------------------------------------------- split A
+    formulas = read_csv(A_DIR / "formula_split.csv")
+    rff = read_csv(A_DIR / "row_formula_fold.csv")
+    test_spectra = read_csv(A_DIR / "test_spectra.csv")
+    val_spectra = read_csv(A_DIR / "val_spectra.csv")
+    vote_official = read_csv(A_DIR / "test_molecules_voting.csv")
+    vote_canonical = read_csv(A_DIR / "test_molecules_voting_canonical_view.csv")
+
+    check("A: formula_split columns", list(formulas[0]) == ["formula", "fold", "n_spectra"], str(list(formulas[0])))
+    check("A: formula_split has 21,107 unique formulas",
+          len(formulas) == A_EXPECTED["n_formula"] and len({r["formula"] for r in formulas}) == A_EXPECTED["n_formula"])
+    check("A: formula fold values are train/val/test",
+          {r["fold"] for r in formulas} == {"train", "val", "test"})
+    check("A: formula-level counts 16,885 / 2,110 / 2,112",
+          dict(Counter(r["fold"] for r in formulas)) ==
+          {"train": A_EXPECTED["n_formula_train"], "val": A_EXPECTED["n_formula_val"], "test": A_EXPECTED["n_formula_test"]},
+          str(dict(Counter(r["fold"] for r in formulas))))
+    spectra_by_fold = Counter()
+    for r in formulas:
+        spectra_by_fold[r["fold"]] += int(r["n_spectra"])
+    check("A: spectra counts 446,667 / 55,980 / 57,437",
+          dict(spectra_by_fold) ==
+          {"train": A_EXPECTED["n_spectra_train"], "val": A_EXPECTED["n_spectra_val"], "test": A_EXPECTED["n_spectra_test"]},
+          str(dict(spectra_by_fold)))
+    check("A: total spectra = 560,084", sum(spectra_by_fold.values()) == A_EXPECTED["n_spectra_total"])
+
+    check("A: row_formula_fold covers rows 0..560,083 in order",
+          [int(r["row_index"]) for r in rff] == list(range(A_EXPECTED["n_spectra_total"])))
+    per_formula = defaultdict(set)
+    per_formula_count = Counter()
+    per_row_fold = Counter()
+    for r in rff:
+        per_formula[r["formula"]].add(r["fold"])
+        per_formula_count[r["formula"]] += 1
+        per_row_fold[r["fold"]] += 1
+    check("A: every formula occurs in exactly one fold",
+          len(per_formula) == A_EXPECTED["n_formula"] and max(len(v) for v in per_formula.values()) == 1)
+    check("A: row_formula_fold agrees with formula_split (fold and n_spectra)",
+          all(per_formula_count[r["formula"]] == int(r["n_spectra"]) and per_formula[r["formula"]] == {r["fold"]}
+              for r in formulas))
+    check("A: row-level fold totals match formula_split",
+          dict(per_row_fold) == dict(spectra_by_fold))
+    fold_by_row = {int(r["row_index"]): r["fold"] for r in rff}
+
+    check("A: test_spectra columns are the released schema",
+          list(test_spectra[0]) == ["row_index", "smiles", "precursor_mz", "adduct", "collision_energy",
+                                    "fold", "canonical_isomeric_smiles"], str(list(test_spectra[0])))
+    check("A: test_spectra has 57,437 rows, all fold=test",
+          len(test_spectra) == A_EXPECTED["n_test_spectra"]
+          and {r["fold"] for r in test_spectra} == {"test"})
+    test_rows_expected = [i for i, fold in fold_by_row.items() if fold == "test"]
+    check("A: test_spectra row_index equals the rows marked test in row_formula_fold",
+          [int(r["row_index"]) for r in test_spectra] == test_rows_expected)
+    check("A: val_spectra has 55,980 rows, all fold=val",
+          len(val_spectra) == A_EXPECTED["n_val_spectra"]
+          and {r["fold"] for r in val_spectra} == {"val"})
+    val_rows_expected = [i for i, fold in fold_by_row.items() if fold == "val"]
+    check("A: val_spectra row_index equals the rows marked val in row_formula_fold",
+          [int(r["row_index"]) for r in val_spectra] == val_rows_expected)
+
+    smiles_groups = Counter(r["smiles"] for r in test_spectra)
+    smiles_ge2 = sorted((smi, n) for smi, n in smiles_groups.items() if n >= 2)
+    check("A: official voting-unit table columns are group_id, smiles, n_spectra",
+          list(vote_official[0]) == ["group_id", "smiles", "n_spectra"], str(list(vote_official[0])))
+    check("A: official voting-unit table (MSnLib source SMILES) reproduces from test_spectra",
+          [(r["smiles"], int(r["n_spectra"])) for r in vote_official] == smiles_ge2)
+    check("A: official voting-unit table has 5,002 groups / 57,436 spectra",
+          len(vote_official) == A_EXPECTED["n_voting_official"]
+          and sum(int(r["n_spectra"]) for r in vote_official) == A_EXPECTED["n_voting_official_spectra"])
+    canon_groups = Counter(r["canonical_isomeric_smiles"] for r in test_spectra)
+    canon_ge2 = sorted((smi, n) for smi, n in canon_groups.items() if n >= 2)
+    check("A: canonical-view table columns are group_id, canonical_isomeric_smiles, n_spectra",
+          list(vote_canonical[0]) == ["group_id", "canonical_isomeric_smiles", "n_spectra"],
+          str(list(vote_canonical[0])))
+    check("A: canonical-view table reproduces from test_spectra",
+          [(r["canonical_isomeric_smiles"], int(r["n_spectra"])) for r in vote_canonical] == canon_ge2)
+    check("A: canonical-view table has 4,888 groups / 57,436 spectra",
+          len(vote_canonical) == A_EXPECTED["n_voting_canonical"]
+          and sum(int(r["n_spectra"]) for r in vote_canonical) == A_EXPECTED["n_voting_canonical_spectra"])
+    singletons = [smi for smi, n in canon_groups.items() if n == 1]
+    check("A: exactly one test spectrum lies outside the voting tables",
+          len(singletons) == 1 and smiles_groups[singletons[0]] == 1,
+          singletons[0] if singletons else "")
+
+    # retention-time companion table (split A row metadata, gzipped only)
+    rt_path = A_DIR / "msnlib_rt.csv.gz"
+    rt_doc = stats["splits"]["A"].get("retention_times", {})
+    check("A: retention-time companion table is shipped and matches stats.json",
+          rt_path.is_file() and rt_doc.get("bytes") == rt_path.stat().st_size
+          and rt_doc.get("sha256") == sha256_file(rt_path),
+          str(rt_doc.get("file")))
+    with gzip.open(rt_path, "rt", newline="") as fh:
+        rt_rows = list(csv.DictReader(fh))
+    check("A: retention-time table columns are row_index, rt",
+          bool(rt_rows) and list(rt_rows[0]) == ["row_index", "rt"],
+          str(list(rt_rows[0]) if rt_rows else []))
+    check("A: retention-time table has 560,084 rows in row order",
+          len(rt_rows) == A_EXPECTED["n_spectra_total"]
+          and [int(r["row_index"]) for r in rt_rows] == list(range(A_EXPECTED["n_spectra_total"])))
+    nonnumeric = []
+    empty = []
+    for r in rt_rows:
+        if not r["rt"].strip():
+            empty.append(r["row_index"])
+            continue
+        try:
+            float(r["rt"])
+        except ValueError:
+            nonnumeric.append(r["row_index"])
+    check("A: every retention time is present and numeric",
+          not empty and not nonnumeric, f"{len(empty)} empty, {len(nonnumeric)} non-numeric")
+
+    # ---------------------------------------------------------------- cross-split A x B
+    cross_stats = stats["cross_split"]
+    b_rows = set()
+    for mode in MODES:
+        for split in ("val", "test"):
+            for sub, role in (("queries", "query"), ("libraries", "library")):
+                path = PKG / f"{sub}/{mode}_{split}_{'queries' if role == 'query' else 'library'}.csv"
+                for r in read_csv(path):
+                    b_rows.add(int(r["msnlib_csv_data_row"]))
+    check("A/B: every split-B table row exists in row_formula_fold",
+          b_rows <= set(fold_by_row), f"{len(b_rows - set(fold_by_row))} missing")
+    check("A/B: split-B tables cover all 441,829 preprocessed spectra",
+          len(b_rows) == 301636 + 140193, f"{len(b_rows)}")
+
+    compound_matrix = {}
+    spectra_matrix = {}
+    for mode in MODES:
+        split_rows = read_csv(PKG / f"splits/{mode}_compound_split.csv")
+        matrix = defaultdict(Counter)
+        for r in split_rows:
+            matrix[r["split"]][fold_by_row[int(r["first_msnlib_csv_data_row"])]] += 1
+        compound_matrix[mode] = {b: dict(sorted(c.items())) for b, c in sorted(matrix.items())}
+        smatrix = defaultdict(Counter)
+        for split in ("val", "test"):
+            for sub, role in (("queries", "query"), ("libraries", "library")):
+                path = PKG / f"{sub}/{mode}_{split}_{'queries' if role == 'query' else 'library'}.csv"
+                for r in read_csv(path):
+                    b_split = r["split"] if role == "query" else r["compound_split"]
+                    smatrix[f"{b_split}/{role}"][fold_by_row[int(r["msnlib_csv_data_row"])]] += 1
+        spectra_matrix[mode] = {k: dict(sorted(c.items())) for k, c in sorted(smatrix.items())}
+    check("A/B: compound-level cross tab reproduces stats.json",
+          compound_matrix == cross_stats["compound_cross_tab"])
+    check("A/B: spectra-level cross tab reproduces stats.json",
+          spectra_matrix == cross_stats["spectra_cross_tab"])
+
+    # row-level matrix: every preprocessed split-B row -> compound -> split-B fold -> split-A fold
+    row_matrix = {}
+    for mode in MODES:
+        mode_smiles = json.loads((PKG / f"protocol/smiles_{mode}.json").read_text())
+        mode_meta = np.load(PKG / f"protocol/derived/row_metadata_{mode}.npz")
+        mode_split = {r["canonical_isomeric_smiles"]: r["split"]
+                      for r in read_csv(PKG / f"splits/{mode}_compound_split.csv")}
+        matrix = defaultdict(Counter)
+        for source_row, smiles_index in zip(mode_meta["source_row"].tolist(),
+                                            mode_meta["smiles_index"].tolist()):
+            matrix[mode_split[mode_smiles[int(smiles_index)]]][fold_by_row[int(source_row)]] += 1
+        row_matrix[mode] = {b: dict(sorted(c.items())) for b, c in sorted(matrix.items())}
+    check("A/B: row-level split-B x split-A cross tab reproduces stats.json",
+          row_matrix == cross_stats["row_cross_tab"])
+    check("A/B: row-level split-B totals equal the manifest split-spectra counts",
+          all(sum(sum(c.values()) for c in row_matrix[mode].values()) ==
+              sum(stats["splits"]["B"]["modes"][mode]["split_spectra_counts"].values())
+              for mode in MODES))
+
+    a_test = {row for row, fold in fold_by_row.items() if fold == "test"}
+    for mode in MODES:
+        overlap = cross_stats["overlap"][mode]
+        mode_rows = set()
+        for split in ("val", "test"):
+            for sub, role in (("queries", "query"), ("libraries", "library")):
+                path = PKG / f"{sub}/{mode}_{split}_{'queries' if role == 'query' else 'library'}.csv"
+                for r in read_csv(path):
+                    mode_rows.add(int(r["msnlib_csv_data_row"]))
+        check(f"A/B/{mode}: A-test rows inside the split-B tables reproduce stats.json",
+              len(a_test & mode_rows) == overlap["A_test_rows_present_in_B_tables"],
+              f"{len(a_test & mode_rows)} vs {overlap['A_test_rows_present_in_B_tables']}")
+
+    # every split-B compound must map to one formula -> one split-A fold
+    consistent = True
+    for mode in MODES:
+        rows_of_compound = defaultdict(set)
+        for split in ("val", "test"):
+            for sub, role in (("queries", "query"), ("libraries", "library")):
+                path = PKG / f"{sub}/{mode}_{split}_{'queries' if role == 'query' else 'library'}.csv"
+                for r in read_csv(path):
+                    rows_of_compound[r["canonical_isomeric_smiles"]].add(
+                        fold_by_row[int(r["msnlib_csv_data_row"])])
+        consistent = consistent and all(len(v) == 1 for v in rows_of_compound.values())
+    check("A/B: every split-B compound has a single split-A fold (same formula)", consistent)
+
+    # ---------------------------------------------------------------- manifest integrity
+    documented_files = set(stats["files"])
+    shipped = {str(p.relative_to(PKG)) for p in PKG.rglob("*") if p.is_file()}
+    shipped.discard("stats.json")
+    shipped.discard("SHA256SUMS")
+    check("stats.json documents exactly the shipped files (except stats.json and SHA256SUMS)",
+          documented_files == shipped,
+          f"missing={sorted(shipped - documented_files)[:5]} extra={sorted(documented_files - shipped)[:5]}")
+    bad_files = []
+    for rel, info in stats["files"].items():
+        path = PKG / rel
+        if path.stat().st_size != info["bytes"] or sha256_file(path) != info["sha256"]:
+            bad_files.append(rel)
+    check("stats.json byte sizes and sha256 match every shipped file", not bad_files, ",".join(bad_files[:5]))
+
+    sums = (PKG / "SHA256SUMS").read_text().splitlines()
+    listed = {}
+    sums_ok = True
+    for line in sums:
+        if not line.strip():
+            continue
+        digest, _, rel = line.partition("  ")
+        if len(digest) != 64 or not rel:
+            sums_ok = False
+            break
+        listed[rel] = digest
+    check("SHA256SUMS parses as '<sha256>  <path>' lines", sums_ok)
+    check("SHA256SUMS covers every shipped file except itself",
+          set(listed) == {str(p.relative_to(PKG)) for p in PKG.rglob("*") if p.is_file()} - {"SHA256SUMS"},
+          f"{len(listed)} entries")
+    check("SHA256SUMS hashes match the files",
+          all(sha256_file(PKG / rel) == digest for rel, digest in listed.items()))
+
+    # ---------------------------------------------------------------- release hygiene
+    text_suffixes = {".md", ".py", ".json", ".sh", ".csv", ".txt", ".cff", ""}
+    offenders = []
+    secret_hits = []
+    for path in PKG.rglob("*"):
+        if not path.is_file() or path.suffix not in text_suffixes:
+            continue
+        if path.name == "SHA256SUMS":
+            continue
+        try:
+            text = path.read_text(errors="ignore")
+        except OSError:
+            continue
+        lowered = text.lower()
+        for name in FORBIDDEN_NAMES:
+            if name in lowered:
+                offenders.append(f"{path.relative_to(PKG)}:{name}")
+        for pattern in FORBIDDEN_PATH_TOKENS:
+            if pattern in text:
+                secret_hits.append(f"{path.relative_to(PKG)}:{pattern}")
+    check("no retired legacy project naming anywhere in the shipped text files",
+          not offenders, ",".join(offenders[:5]))
+    check("no internal absolute paths or private keys in the shipped text files",
+          not secret_hits, ",".join(secret_hits[:5]))
+
+    failed = [name for name, ok, _ in CHECKS if not ok]
+    print(f"\n{len(CHECKS) - len(failed)}/{len(CHECKS)} checks passed")
+    if failed:
+        print("FAILED:", *failed, sep="\n  ")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

split_A_full_msnlib/README.md

@@ -0,0 +1,107 @@
+# UltraMS MSnLib formula-level split (split A)
+
+Version **1.0.0** · 2026-11-04 · license **CC BY 4.0**
+
+The frozen, **formula-disjoint** 80/10/10 train / validation / test split of the complete
+MSnLib tandem mass spectral library (560,084 spectra, all adducts). This directory is also
+shipped as `split_A_full_msnlib/` inside `ultrams_msnlib_benchmark_v1/`.
+
+| | train | validation | test | total |
+| --- | ---: | ---: | ---: | ---: |
+| molecular formulas | 16,885 | 2,110 | 2,112 | 21,107 |
+| spectra | 446,667 | 55,980 | 57,437 | 560,084 |
+
+Every spectrum of a molecular formula lies in exactly one fold; no formula occurs in two
+folds. The frozen assignment is the `fold` column of `MSnLib.csv` and the split is replayed
+exactly by [`build_split_a.py`](build_split_a.py).
+
+## Files
+
+| file | rows | content |
+| --- | ---: | --- |
+| `formula_split.csv(.gz)` | 21,107 | `formula, fold, n_spectra` — one row per molecular formula |
+| `row_formula_fold.csv(.gz)` | 560,084 | `row_index, formula, fold` — authoritative row → formula → fold map for all spectra |
+| `test_spectra.csv(.gz)` | 57,437 | `row_index, smiles, precursor_mz, adduct, collision_energy, fold, canonical_isomeric_smiles` |
+| `val_spectra.csv(.gz)` | 55,980 | same schema for the validation fold |
+| `msnlib_rt.csv.gz` | 560,084 | `row_index, rt` — compact per-spectrum retention time (seconds); gzipped only |
+| `test_molecules_voting.csv(.gz)` | 5,002 | **official** multiple-spectrum voting units (Figure 3d / 3a voting): the test spectra grouped by the MSnLib source SMILES string, group size ≥ 2 (57,436 spectra); reproduces the published voting task's `n_molecules = 5002` grouping member-for-member |
+| `test_molecules_voting_canonical_view.csv(.gz)` | 4,888 | alternative canonical view (not the official unit): the same test spectra grouped by RDKit canonical isomeric SMILES, group size ≥ 2 (57,436 spectra) |
+| `REPORT.json` | | machine-readable report: counts, expected values, hashes, cross-checks, anomaly record |
+| `VERIFY.md` | | full verification record (inputs, counts, cross-checks, replay transcript) |
+| `build_split_a.py` | | replay from `MSnLib.csv` and SHA-256 check against the frozen tables |
+
+`row_index` is the 0-based data row of `MSnLib.csv` (560,084 rows, 752,707,651 bytes,
+SHA-256 `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07`; physical
+line = data row + 2). Every `.csv` has a `.csv.gz` twin that decompresses to the identical
+bytes.
+
+## Official voting units (Figure 3d / Figure 3a voting)
+
+The official multiple-spectrum voting unit is the **MSnLib source SMILES string**. The
+57,437 test spectra contain 5,003 distinct source strings; one of them occurs in only one
+spectrum, so `test_molecules_voting.csv` has **5,002 groups covering 57,436 spectra**. This
+is the grouping of the published multiple-spectrum voting task and it is verified
+member-for-member against the repository voting table (`n_molecules = 5002`).
+
+For a chemically deduplicated view, `test_molecules_voting_canonical_view.csv` groups the
+same spectra by RDKit canonical isomeric SMILES: 4,889 distinct molecules, of which
+**4,888 groups cover the same 57,436 spectra**. 114 source-string groups merge into
+chemically identical molecules, and the single excluded molecule is
+`CC(C)(C)OC(=O)NCC1(CC(=O)O)CCCCC1`. The canonical view is an alternative, **not** the
+official voting unit. See `VERIFY.md` §7.
+
+## Retention times (RT)
+
+`msnlib_rt.csv.gz` is a compact companion table (1.4 MB gzipped, no 756 MB full CSV):
+`row_index` is the 0-based `MSnLib.csv` data row (0 … 560,083) and `rt` is the retention time
+in seconds, kept in the source text representation. It was exported from
+`MSnLib_with_rt.csv` (755,984,910 bytes, SHA-256
+`a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964`, columns
+`mzs,intensities,smiles,precursor_mz,adduct,collision_energy,fold,rt`) after verifying
+row-by-row that its first seven columns are identical to `MSnLib.csv` in the same order
+(560,084/560,084 rows, 0 mismatches). RT is source metadata from the MSnLib records
+(CC BY 4.0; see `NOTICE.md` / the parent package `NOTICE.md`).
+
+```python
+import gzip
+import pandas as pd
+
+test = pd.read_csv("test_spectra.csv")
+rt = pd.read_csv("msnlib_rt.csv.gz")           # row_index, rt
+test_rt = test.merge(rt, on="row_index", how="left")
+assert test_rt["rt"].notna().all()
+```
+
+The table is needed by the label-blind grouping / multiple-spectrum voting analyses
+(Figure 3d), which use RT as spectrum metadata.
+
+## Quick start
+
+```python
+import pandas as pd
+
+formulas = pd.read_csv("formula_split.csv")
+test = pd.read_csv("test_spectra.csv")
+rows = pd.read_csv("row_formula_fold.csv")          # 560,084 rows
+
+# formula-level disjointness: one fold per formula
+assert formulas.groupby("formula")["fold"].nunique().max() == 1
+assert formulas["n_spectra"].sum() == 560_084
+```
+
+## Rebuild and verify
+
+```bash
+# read-only replay + hash check (needs MSnLib.csv and RDKit 2026.03.5):
+python3 build_split_a.py --csv /path/to/datasets/MSnLib/MSnLib.csv
+
+# write the tables (byte-identical with the frozen copies under RDKit 2026.03.5):
+python3 build_split_a.py --csv /path/to/MSnLib.csv --output-dir replay_split_a
+```
+
+The split is **formula-disjoint, not molecule-disjoint**: different molecules can share a
+formula and therefore a fold. The molecule-disjoint benchmark is split B
+(strict-adduct 70/15/15) of `ultrams_msnlib_benchmark_v1/`; the two splits must never be
+combined into a single global-disjointness claim. See `figures_mapping.md` in the parent
+package for which manuscript panels use which split, and `NOTICE.md` for the MSnLib
+attribution (Brungs et al., Zenodo 10.5281/zenodo.11163380, CC BY 4.0).

split_A_full_msnlib/REPORT.json

@@ -0,0 +1,484 @@
+{
+  "name": "UltraMS MSnLib formula-level split",
+  "short_name": "UltraMS MSnLib split A (full library, formula-disjoint 80/10/10)",
+  "version": "1.0.0",
+  "date": "2026-11-04",
+  "license": "CC BY 4.0",
+  "description": "Frozen formula-level train/validation/test split of the complete MSnLib tandem mass spectral library (560,084 spectra, all adducts). Every spectrum of a molecular formula lies in exactly one fold; the three folds are disjoint at the molecular-formula level. This is the benchmark population for candidate ranking, multiple-spectrum voting, label-blind grouping and embedding analyses of the UltraMS manuscript (Figures 2b/2j, 3a/3b/3d/3g, 3a_sp_4, 3a_sp_5 and the single-spectrum baselines).",
+  "definition": {
+    "unit": "neutral molecular formula, computed with RDKit rdMolDescriptors.CalcMolFormula(Chem.MolFromSmiles(smiles))",
+    "assignment": "the frozen `fold` column of MSnLib.csv; this file is the frozen benchmark definition",
+    "proportions": "frozen, approximately 80/10/10 by formula group (train 80.0%, val 10.0%, test 10.0%)",
+    "rule": "formula-disjoint: all spectra sharing a formula lie in the same fold (0 conflicting formulas observed)",
+    "not_molecule_disjoint": "the same canonical molecule can occur in more than one fold when its SMILES variants have different molecular formulas is impossible, but a formula can contain several molecules; molecule-level disjointness is provided only by split B of the UltraMS MSnLib benchmark package"
+  },
+  "source": {
+    "msnlib_csv": {
+      "path_in_data_workspace": "datasets/MSnLib/MSnLib.csv",
+      "data_rows": 560084,
+      "bytes": 752707651,
+      "sha256": "be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07",
+      "columns": [
+        "mzs",
+        "intensities",
+        "smiles",
+        "precursor_mz",
+        "adduct",
+        "collision_energy",
+        "fold"
+      ],
+      "csv_line_to_data_row": "physical line = data row + 2 (header = line 1, no embedded newlines)"
+    },
+    "msnlib_original_release": {
+      "citation": "Brungs C., Schmid R., Pluskal T. MSnLib: efficient generation of open multi-stage fragmentation mass spectral libraries. Zenodo record 10.5281/zenodo.11163380 (2024), CC BY 4.0.",
+      "zenodo_record": "11163380",
+      "format": "per-file JSONL record lists (*_ms2.json)",
+      "n_files": 18,
+      "n_records_total": 560084,
+      "note": "the 18 MSnLib original MS2 JSONL files contain exactly 560,084 records, equal to the MSnLib.csv data-row count"
+    },
+    "msnlib_with_rt": {
+      "path_in_data_workspace": "datasets/MSnLib/MSnLib_with_rt.csv",
+      "bytes": 755984910,
+      "sha256": "a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964",
+      "columns": [
+        "mzs",
+        "intensities",
+        "smiles",
+        "precursor_mz",
+        "adduct",
+        "collision_energy",
+        "fold",
+        "rt"
+      ],
+      "note": "source of the compact retention-time table; verified row-by-row to have the same row order and the same first seven columns as MSnLib.csv (560,084 rows, 0 mismatches)"
+    }
+  },
+  "method": [
+    "read MSnLib.csv in source order (560,084 data rows)",
+    "cache RDKit formula and canonical isomeric SMILES per distinct source SMILES string (48,597 distinct strings)",
+    "verify that the fold label is a function of the molecular formula: every formula occurs in exactly one fold",
+    "write formula_split.csv (formula, fold, n_spectra), row_formula_fold.csv (all 560,084 rows), the test and validation spectra tables and the two multiple-spectrum voting tables",
+    "cross-check the exported test/validation spectra against the historical per-fold CSV files and sample the recorded `formula` fields of the MSnLib original JSON records"
+  ],
+  "environment": {
+    "run": "isolated data-preparation environment with read-only access to the MSnLib data workspace; nothing was written on the remote side",
+    "python": "3.10.12",
+    "rdkit": "2026.03.5",
+    "numpy": "2.2.6",
+    "local_postprocessing": "macOS, Python 3.13.11, numpy 2.4.4, pandas 3.0.3, RDKit 2026.03.3 (only gzip generation, the canonical voting view and cross-checks)"
+  },
+  "expected_vs_observed": {
+    "n_data_rows": {
+      "expected": 560084,
+      "observed": 560084,
+      "match": true
+    },
+    "n_unique_formula": {
+      "expected": 21107,
+      "observed": 21107,
+      "match": true
+    },
+    "n_formula_groups_train": {
+      "expected": 16885,
+      "observed": 16885,
+      "match": true
+    },
+    "n_formula_groups_val": {
+      "expected": 2110,
+      "observed": 2110,
+      "match": true
+    },
+    "n_formula_groups_test": {
+      "expected": 2112,
+      "observed": 2112,
+      "match": true
+    },
+    "n_spectra_train": {
+      "expected": 446667,
+      "observed": 446667,
+      "match": true
+    },
+    "n_spectra_val": {
+      "expected": 55980,
+      "observed": 55980,
+      "match": true
+    },
+    "n_spectra_test": {
+      "expected": 57437,
+      "observed": 57437,
+      "match": true
+    },
+    "n_formula_conflicts": {
+      "expected": 0,
+      "observed": 0,
+      "match": true
+    },
+    "n_rdkit_parse_failures": {
+      "expected": 0,
+      "observed": 0,
+      "match": true
+    },
+    "voting_groups_official_source_smiles": {
+      "expected": 5002,
+      "observed": 5002,
+      "match": true
+    },
+    "voting_spectra_official_source_smiles": {
+      "expected": 57436,
+      "observed": 57436,
+      "match": true
+    },
+    "voting_groups_canonical_view": {
+      "expected": 4888,
+      "observed": 4888,
+      "match": true
+    },
+    "voting_spectra_canonical_view": {
+      "expected": 57436,
+      "observed": 57436,
+      "match": true
+    }
+  },
+  "counts": {
+    "unique_formula_total": 21107,
+    "unique_formula_by_fold": {
+      "train": 16885,
+      "val": 2110,
+      "test": 2112
+    },
+    "spectra_by_fold": {
+      "train": 446667,
+      "val": 55980,
+      "test": 57437
+    },
+    "spectra_per_formula": {
+      "min": 1,
+      "max": 627,
+      "mean": 26.535,
+      "median": 15,
+      "n_formulas_with_one_spectrum": 25
+    },
+    "unique_raw_smiles_total": 48597,
+    "unique_canonical_isomeric_smiles_total": 47662,
+    "canonical_smiles_with_multiple_source_variants": 935,
+    "test": {
+      "n_spectra": 57437,
+      "n_formulas": 2112,
+      "n_unique_source_smiles": 5003,
+      "n_unique_canonical_isomeric_smiles": 4889,
+      "n_adducts": 11,
+      "adduct_counts": {
+        "[M+H]+": 31763,
+        "[M-H]-": 13824,
+        "[M+FA]-": 5884,
+        "[M+Cl]-": 2403,
+        "[M+H-H2O]+": 1252,
+        "[M+NH4]+": 1189,
+        "[M+Na]+": 583,
+        "[M]+": 287,
+        "[M+H-2H2O]+": 169,
+        "[M-H2O]+": 59,
+        "[M]-": 24
+      },
+      "collision_energy_counts": {
+        "15.0": 4264,
+        "20.0": 30383,
+        "30.0": 6041,
+        "45.0": 3289,
+        "60.0": 13429,
+        "75.0": 31
+      }
+    },
+    "validation": {
+      "n_spectra": 55980,
+      "n_formulas": 2110,
+      "n_unique_source_smiles": 4883,
+      "n_unique_canonical_isomeric_smiles": 4786,
+      "n_adducts": 11,
+      "adduct_counts": {
+        "[M+H]+": 30210,
+        "[M-H]-": 14160,
+        "[M+FA]-": 5700,
+        "[M+Cl]-": 2614,
+        "[M+H-H2O]+": 1070,
+        "[M+NH4]+": 1043,
+        "[M+Na]+": 597,
+        "[M]+": 330,
+        "[M+H-2H2O]+": 193,
+        "[M-H2O]+": 36,
+        "[M]-": 27
+      }
+    }
+  },
+  "tables": {
+    "formula_split.csv": {
+      "columns": [
+        "formula",
+        "fold",
+        "n_spectra"
+      ],
+      "n_rows": 21107,
+      "ordering": "fold order train, val, test; then formula lexicographically",
+      "bytes": 424350,
+      "sha256": "fcc44d1996d25306c884a6f8da30c1447fbe74f93c6fa12a3f271c0475a704b8",
+      "gzip": {
+        "bytes": 86748,
+        "sha256": "d52d77139c06d8662972fa638981894cf9f88fb3a5da1e1b73017b939d19fd4a"
+      }
+    },
+    "row_formula_fold.csv": {
+      "columns": [
+        "row_index",
+        "formula",
+        "fold"
+      ],
+      "n_rows": 560084,
+      "ordering": "MSnLib.csv data-row order (row_index = 0 .. 560,083)",
+      "bytes": 13351630,
+      "sha256": "ac6113867fdda683304533f097fc7287c13271a2deac8e792d1316dcf00264ff",
+      "gzip": {
+        "bytes": 1248826,
+        "sha256": "86150a89fb601a117d43c995065c3abc95ab0710cb80ffe47dfa5413aa57e686"
+      }
+    },
+    "test_spectra.csv": {
+      "columns": [
+        "row_index",
+        "smiles",
+        "precursor_mz",
+        "adduct",
+        "collision_energy",
+        "fold",
+        "canonical_isomeric_smiles"
+      ],
+      "n_rows": 57437,
+      "ordering": "MSnLib.csv data-row order",
+      "bytes": 7751575,
+      "sha256": "f2a870ba8ac9a54a36feaf1ecc12929ad9250ade2d082dc31454028c4b66b548",
+      "gzip": {
+        "bytes": 409844,
+        "sha256": "afb5c538d969bbfccd626a02a78572083a0830a8af0c52a39a45403e3ec71352"
+      }
+    },
+    "val_spectra.csv": {
+      "columns": [
+        "row_index",
+        "smiles",
+        "precursor_mz",
+        "adduct",
+        "collision_energy",
+        "fold",
+        "canonical_isomeric_smiles"
+      ],
+      "n_rows": 55980,
+      "ordering": "MSnLib.csv data-row order",
+      "bytes": 7421554,
+      "sha256": "f4fa5e0f8875991bf9df2bcb67a05437271ee18c317f33d9108f3ec28a887a82",
+      "gzip": {
+        "bytes": 401530,
+        "sha256": "d2e45289b564b40998479e7c3fe7b283097f1a9aebe798e369b259c7f1851cce"
+      }
+    },
+    "test_molecules_voting.csv": {
+      "columns": [
+        "group_id",
+        "smiles",
+        "n_spectra"
+      ],
+      "n_rows": 5002,
+      "n_spectra": 57436,
+      "role": "official multiple-spectrum voting units (Figure 3d / 3a voting): test spectra grouped by the MSnLib source SMILES string; group_id = 0-based rank over sorted source SMILES",
+      "bytes": 276185,
+      "sha256": "edad6ec7d6b6f9fc4763deac5245207aee767c78661532621c87acc5a9b1ee07",
+      "gzip": {
+        "bytes": 72880,
+        "sha256": "72ae163ce88b15d89fb1d556fbb8a698d001dd1e923df11399df13dfddec3db2"
+      }
+    },
+    "test_molecules_voting_canonical_view.csv": {
+      "columns": [
+        "group_id",
+        "canonical_isomeric_smiles",
+        "n_spectra"
+      ],
+      "n_rows": 4888,
+      "n_spectra": 57436,
+      "role": "alternative canonical view (not the official voting unit): the same test spectra grouped by RDKit canonical isomeric SMILES",
+      "bytes": 269502,
+      "sha256": "9fcd16ff4159e665833ea145848f94bee7c44115f4a858dd75fe486f15e92bd0",
+      "gzip": {
+        "bytes": 70897,
+        "sha256": "332c03eab3e9f91b0f956c59cd01c22f633166bd285e9942f5507839625f5bc0"
+      }
+    },
+    "msnlib_rt.csv.gz": {
+      "columns": [
+        "row_index",
+        "rt"
+      ],
+      "n_rows": 560084,
+      "role": "compact per-spectrum retention time (seconds), 0-based MSnLib.csv data row order; gzipped only to keep the package compact",
+      "bytes": 1483069,
+      "sha256": "994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8",
+      "note": "exported from MSnLib_with_rt.csv after a row-by-row first-seven-column alignment check (560,084 rows, 0 mismatches, 0 unparsable RT values)"
+    }
+  },
+  "verification": {
+    "formula_level_consistency": {
+      "n_formulas_with_more_than_one_fold": 0,
+      "n_raw_smiles_with_more_than_one_fold": 0,
+      "n_canonical_molecules_with_more_than_one_fold": 0,
+      "status": "PASS (every formula belongs to exactly one fold)"
+    },
+    "rdkit_parsing": {
+      "n_parse_failures": 0,
+      "n_unique_smiles": 48597,
+      "status": "PASS (all 48,597 distinct source SMILES parse)"
+    },
+    "historical_fold_csv_cross_check": {
+      "test": {
+        "path": "datasets/MSnLib/MSnLib_test.csv",
+        "label": "test",
+        "status": "match",
+        "n_rows": 57437,
+        "n_expected": 57437,
+        "mismatch_examples": []
+      },
+      "validation": {
+        "path": "datasets/MSnLib/MSnLib_val.csv",
+        "label": "val",
+        "status": "match",
+        "n_rows": 55980,
+        "n_expected": 55980,
+        "mismatch_examples": []
+      },
+      "checked_columns": [
+        "smiles",
+        "precursor_mz",
+        "adduct",
+        "collision_energy"
+      ],
+      "status": "PASS (row order and values identical)"
+    },
+    "msnlib_original_formula_cross_check": {
+      "files_checked_first_record": 18,
+      "first_record_formula_mismatches": 0,
+      "streamed_records": 37177,
+      "streamed_formula_mismatches": 0,
+      "streamed_files": [
+        "20241003_enammol_neg_ms2.json",
+        "20241003_enammol_pos_ms2.json"
+      ],
+      "sample_formula_C10H10BrN5O2": {
+        "n_original_records_checked": 3,
+        "n_rdkit_equals_record_formula": 3,
+        "records": [
+          {
+            "file": "20241003_mcescaf_pos_ms2.json",
+            "line": 9998,
+            "smiles": "O=C1CNC(=O)N1C1CN(c2ncc(Br)cn2)C1",
+            "record_formula": "C10H10BrN5O2",
+            "rdkit_formula": "C10H10BrN5O2",
+            "adduct": "[M+H]+"
+          },
+          {
+            "file": "20250828_mcediv_50k_sub_neg_ms2.json",
+            "line": 23736,
+            "smiles": "O=C1CNC(=O)N1C1CN(c2ncc(Br)cn2)C1",
+            "record_formula": "C10H10BrN5O2",
+            "rdkit_formula": "C10H10BrN5O2",
+            "adduct": "[M-H]-"
+          },
+          {
+            "file": "20250828_mcediv_50k_sub_pos_ms2.json",
+            "line": 2551,
+            "smiles": "COc1ccc(Br)cc1C(=O)Nc1nnn(C)n1",
+            "record_formula": "C10H10BrN5O2",
+            "rdkit_formula": "C10H10BrN5O2",
+            "adduct": "[M+H]+"
+          }
+        ],
+        "msnlib_csv_spectra_with_this_formula": 23,
+        "msnlib_csv_folds": {
+          "train": 23
+        }
+      },
+      "status": "PASS (recorded formula field equals the RDKit formula of the recorded SMILES)"
+    },
+    "repository_voting_table_cross_check": {
+      "repository_file": "benchmarks/molecular_identification/data/multiple_spectrum_voting_summary.csv",
+      "repository_n_molecules": 5002,
+      "our_grouping_matching_repository": "test_molecules_voting.csv",
+      "repository_comparison_table": "benchmarks/molecular_identification/data/multiple_spectrum_voting_per_group.csv.gz",
+      "repo_groups": 5002,
+      "repo_spectra": 57436,
+      "smiles_grouping_member_sets_identical": true,
+      "canonical_grouping_member_sets_identical": false,
+      "canonical_groups_merged_from_smiles_groups": 114,
+      "repo_strings_are_source_smiles": true,
+      "status": "PASS for the MSnLib-source-SMILES grouping (member sets identical); the canonical-isomeric-SMILES grouping merges 114 of those groups into 4,888 chemically identical molecules"
+    },
+    "rt_export": {
+      "source_file": "MSnLib_with_rt.csv",
+      "source_bytes": 755984910,
+      "source_sha256": "a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964",
+      "alignment_method": "row-by-row equality of the first seven columns (mzs, intensities, smiles, precursor_mz, adduct, collision_energy, fold) between MSnLib.csv and MSnLib_with_rt.csv, in file order",
+      "n_rows": 560084,
+      "n_row_mismatches": 0,
+      "n_extra_rows": 0,
+      "n_unparsable_rt": 0,
+      "n_distinct_rt_strings": 8369,
+      "rt_is_constant": false,
+      "status": "PASS (same row order and identical first seven columns; RT exported as row_index,rt)"
+    },
+    "replay": {
+      "script": "build_split_a.py",
+      "command": "python3 build_split_a.py --csv datasets/MSnLib/MSnLib.csv   # read-only, no output dir",
+      "run_on": "isolated data-preparation environment (read-only), RDKit 2026.03.5",
+      "status": "PASS (all 12 count checks and all 6 table SHA-256 checks matched; exit 0)",
+      "transcript": [
+        "[PASS] n_data_rows: 560,084 (expected 560,084)",
+        "[PASS] n_unique_formula: 21,107 (expected 21,107)",
+        "[PASS] n_formula_train: 16,885 (expected 16,885)",
+        "[PASS] n_formula_val: 2,110 (expected 2,110)",
+        "[PASS] n_formula_test: 2,112 (expected 2,112)",
+        "[PASS] n_spectra_train: 446,667 (expected 446,667)",
+        "[PASS] n_spectra_val: 55,980 (expected 55,980)",
+        "[PASS] n_spectra_test: 57,437 (expected 57,437)",
+        "[PASS] n_voting_groups_official: 5,002 (expected 5,002)",
+        "[PASS] n_voting_spectra_official: 57,436 (expected 57,436)",
+        "[PASS] n_voting_groups_canonical: 4,888 (expected 4,888)",
+        "[PASS] n_voting_spectra_canonical: 57,436 (expected 57,436)",
+        "[PASS] formula_split.csv: 424,350 bytes sha256 fcc44d1996d25306c884a6f8da30c1447fbe74f93c6fa12a3f271c0475a704b8",
+        "[PASS] row_formula_fold.csv: 13,351,630 bytes sha256 ac6113867fdda683304533f097fc7287c13271a2deac8e792d1316dcf00264ff",
+        "[PASS] test_spectra.csv: 7,751,575 bytes sha256 f2a870ba8ac9a54a36feaf1ecc12929ad9250ade2d082dc31454028c4b66b548",
+        "[PASS] val_spectra.csv: 7,421,554 bytes sha256 f4fa5e0f8875991bf9df2bcb67a05437271ee18c317f33d9108f3ec28a887a82",
+        "[PASS] test_molecules_voting.csv: 276,185 bytes sha256 edad6ec7d6b6f9fc4763deac5245207aee767c78661532621c87acc5a9b1ee07",
+        "[PASS] test_molecules_voting_canonical_view.csv: 269,502 bytes sha256 9fcd16ff4159e665833ea145848f94bee7c44115f4a858dd75fe486f15e92bd0"
+      ]
+    }
+  },
+  "anomalies": [
+    {
+      "id": "official_voting_unit_source_smiles",
+      "severity": "documented definition difference, not a data error",
+      "expected_by_task": "5,002 groups / 57,436 spectra for the published multiple-spectrum voting task (n_molecules = 5002)",
+      "observed": "official MSnLib-source-SMILES grouping: 5,002 groups / 57,436 spectra (test_molecules_voting.csv); RDKit canonical-isomeric-SMILES grouping: 4,888 groups / 57,436 spectra (test_molecules_voting_canonical_view.csv)",
+      "explanation": "The published multiple-spectrum-voting task groups the 57,437 test spectra by the `smiles` field of its frozen single-spectrum records, which is the MSnLib source SMILES string. 5,003 distinct source strings exist for the test fold, one of which occurs in only one spectrum, leaving 5,002 groups covering 57,436 spectra. RDKit canonical isomeric SMILES merges SMILES variants of the same molecule: the test fold has 4,889 distinct canonical molecules, 4,888 of which have >= 2 spectra, again covering 57,436 spectra and leaving the same single-spectrum molecule (CC(C)(C)OC(=O)NCC1(CC(=O)O)CCCCC1) outside the voting table.",
+      "evidence": "our official MSnLib-source-SMILES grouping reproduces the repository `multiple_spectrum_voting_per_group.csv.gz` member sets and group sizes exactly (5,002 groups, 57,436 spectra); the canonical view merges 114 pairs/sets of those groups into chemically identical molecules",
+      "resolution": "the 5,002 source-SMILES groups are the official voting unit for Figure 3d and the Figure 3a voting readouts; the 4,888-group canonical table is an alternative chemical-deduplication view",
+      "tables": [
+        "test_molecules_voting.csv (official, source-string, 5,002 groups)",
+        "test_molecules_voting_canonical_view.csv (alternative canonical view, 4,888 groups)"
+      ]
+    }
+  ],
+  "known_caveats": [
+    "Retention times are source metadata from the MSnLib release (CC BY 4.0). `msnlib_rt.csv.gz` aligns them to `MSnLib.csv` by 0-based data row (`row_index`); it is not one of the six replayable split tables and is shipped gzipped only.",
+    "Molecule identity strings (canonical_isomeric_smiles) were frozen with RDKit 2026.03.5; other RDKit patch releases can serialise the same molecule differently, so compare the published strings, not freshly canonicalised ones. Molecular formulas are stable across RDKit patch releases.",
+    "Split A is formula-disjoint, not molecule-disjoint: different molecules can share a formula and therefore a fold, and a molecule's spectra always share one formula and thus one fold. Split B (molecule-level, strict-adduct) is the only molecule-disjoint resource in this package; the two splits must not be combined into a global disjointness claim.",
+    "Mass spectra are not redistributed in this split directory: the tables carry source row pointers into MSnLib.csv (752,707,651 bytes, SHA-256 be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07) and the MSnLib original release is available under CC BY 4.0.",
+    "row_index refers to MSnLib.csv data rows; its row order follows the frozen UltraMS MSnLib conversion of the MSnLib release records. The authoritative row -> formula -> fold mapping is row_formula_fold.csv."
+  ]
+}

split_A_full_msnlib/VERIFY.md

@@ -0,0 +1,270 @@
+# VERIFY — UltraMS MSnLib formula-level split (split A)
+
+This document records **what was checked, how, and with which exact values** for the
+`msnlib_split_a_v1` tables. The split is a frozen benchmark definition: every spectrum of a
+molecular formula lies in exactly one fold. All numbers below were re-derived from the
+source `MSnLib.csv` and the shipped tables; nothing was written on the remote side.
+
+## 1. Environments
+
+| side | runtime |
+| --- | --- |
+| isolated data-preparation environment (read-only access) | Linux, Python 3.10.12, RDKit 2026.03.5, NumPy 2.2.6 |
+| local post-processing (gzip twins, auxiliary voting table, cross-checks) | macOS, Python 3.13.11, NumPy 2.4.4, pandas 3.0.3, RDKit 2026.03.3 |
+
+The molecular formula and the frozen fold assignment do not depend on the RDKit patch
+release. The canonical isomeric SMILES strings were frozen with RDKit **2026.03.5**; other
+patch releases can serialise the same molecule differently (see §7).
+
+## 2. Inputs
+
+| input | identity |
+| --- | --- |
+| `MSnLib.csv` | 560,084 data rows, 560,085 physical lines (no embedded newlines), 752,707,651 bytes, SHA-256 `be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07`, columns `mzs,intensities,smiles,precursor_mz,adduct,collision_energy,fold` |
+| MSnLib original release | 18 per-file MS2 JSONL releases; 560,084 records in total (equal to the CSV data-row count); CC BY 4.0, Zenodo record 10.5281/zenodo.11163380 |
+| historical per-fold CSV files (cross-check only) | `MSnLib_test.csv` (57,437 rows) and `MSnLib_val.csv` (55,980 rows) in the same data workspace |
+| `MSnLib_with_rt.csv` (retention-time source) | 755,984,910 bytes, SHA-256 `a5b7c38228287c5c1de401050445319b331ee9a5f17993d6e104e9a734fe2964`; columns `mzs,intensities,smiles,precursor_mz,adduct,collision_energy,fold,rt` |
+
+Access to the data workspace was read-only: `MSnLib.csv` and the original JSON records
+were streamed out, the tables were computed in memory, and nothing was written or modified
+on the remote side.
+
+## 3. Definition replayed
+
+1. For every data row, parse `smiles` with `Chem.MolFromSmiles` and compute the neutral
+   molecular formula with `rdMolDescriptors.CalcMolFormula`.
+2. Read the frozen `fold` label of the row.
+3. Require that the fold is a function of the formula only: every formula occurs in exactly
+   one fold.
+4. Export the tables. `row_formula_fold.csv` is the authoritative row → formula → fold
+   mapping for all 560,084 spectra.
+
+## 4. Counts — expected versus observed (all match)
+
+| quantity | expected | observed | status |
+| --- | ---: | ---: | --- |
+| data rows | 560,084 | 560,084 | PASS |
+| unique molecular formulas | 21,107 | 21,107 | PASS |
+| formulas train / validation / test | 16,885 / 2,110 / 2,112 | 16,885 / 2,110 / 2,112 | PASS |
+| spectra train / validation / test | 446,667 / 55,980 / 57,437 | 446,667 / 55,980 / 57,437 | PASS |
+| formulas occurring in more than one fold | 0 | 0 | PASS |
+| RDKit SMILES parse failures | 0 | 0 | PASS |
+| test spectra | 57,437 | 57,437 | PASS |
+| validation spectra | 55,980 | 55,980 | PASS |
+| voting groups, official (MSnLib source SMILES) | 5,002 | 5,002 | PASS |
+| voting spectra, official (MSnLib source SMILES) | 57,436 | 57,436 | PASS |
+| voting groups, canonical view | 4,888 | 4,888 | PASS |
+| voting spectra, canonical view | 57,436 | 57,436 | PASS |
+
+The formula-level proportions are 16,885 / 2,110 / 2,112 formulas (80.00 % / 10.00 % /
+10.01 %) and 446,667 / 55,980 / 57,437 spectra (79.75 % / 9.99 % / 10.25 %).
+
+Additional structure:
+
+| quantity | value |
+| --- | --- |
+| unique source SMILES strings (all adducts) | 48,597 |
+| unique canonical isomeric SMILES (all adducts) | 47,662 |
+| canonical molecules with more than one source SMILES variant | 935 |
+| spectra per formula: min / median / mean / max | 1 / 15 / 26.535 / 627 |
+| formulas with exactly one spectrum | 25 |
+| test formulas | 2,112 |
+| test unique source SMILES / canonical molecules | 5,003 / 4,889 |
+| validation unique source SMILES / canonical molecules | 4,883 / 4,786 |
+| adducts present in the test / validation folds | 11 / 11 |
+
+Test-fold adduct distribution: `[M+H]+` 31,763, `[M-H]-` 13,824, `[M+FA]-` 5,884,
+`[M+Cl]-` 2,403, `[M+H-H2O]+` 1,252, `[M+NH4]+` 1,189, `[M+Na]+` 583, `[M]+` 287,
+`[M+H-2H2O]+` 169, `[M-H2O]+` 59, `[M]-` 24. Collision energies: 15 (4,264), 20 (30,383),
+30 (6,041), 45 (3,289), 60 (13,429) and 75 eV (31).
+
+## 5. Cross-checks against independent sources
+
+### 5.1 Historical per-fold CSV files
+
+The exported test and validation spectra tables were compared row by row (same order) with
+`MSnLib_test.csv` and `MSnLib_val.csv` on `smiles`, `precursor_mz`, `adduct` and
+`collision_energy`:
+
+| file | rows | mismatches | status |
+| --- | ---: | ---: | --- |
+| `MSnLib_test.csv` | 57,437 | 0 | PASS |
+| `MSnLib_val.csv` | 55,980 | 0 | PASS |
+
+### 5.2 `formula` field of the MSnLib original JSON records
+
+The MSnLib original release records carry an independent `formula` field. For every one of
+the 18 original files, the RDKit formula of the **first** record equals the recorded
+`formula` (18/18). Two complete files were streamed and compared record by record:
+
+| file | records | RDKit formula ≠ recorded formula |
+| --- | ---: | ---: |
+| `20241003_enammol_neg_ms2.json` | 12,825 | 0 |
+| `20241003_enammol_pos_ms2.json` | 24,352 | 0 |
+
+For the sample formula **C10H10BrN5O2**, three original records were located and checked;
+the recorded `formula` equals the RDKit formula of the recorded SMILES in all three. Two of
+them are different molecules that share the formula, which is exactly what the formula-level
+split groups together:
+
+| file | line | smiles | adduct |
+| --- | ---: | --- | --- |
+| `20241003_mcescaf_pos_ms2.json` | 9,998 | `O=C1CNC(=O)N1C1CN(c2ncc(Br)cn2)C1` | `[M+H]+` |
+| `20250828_mcediv_50k_sub_neg_ms2.json` | 23,736 | `O=C1CNC(=O)N1C1CN(c2ncc(Br)cn2)C1` | `[M-H]-` |
+| `20250828_mcediv_50k_sub_pos_ms2.json` | 2,551 | `COc1ccc(Br)cc1C(=O)Nc1nnn(C)n1` | `[M+H]+` |
+
+`MSnLib.csv` contains **23** spectra with formula C10H10BrN5O2, all in the **train** fold
+(so the sample formula does not leak into test).
+
+### 5.3 Multiple-spectrum voting table of the UltraMS repository
+
+The repository summary
+`benchmarks/molecular_identification/data/multiple_spectrum_voting_summary.csv` reports
+`n_molecules = 5002` for the multiple-spectrum voting task. The per-group table
+`multiple_spectrum_voting_per_group.csv.gz` (5,002 groups, 57,436 spectra) was compared
+with our groupings:
+
+| comparison | result |
+| --- | --- |
+| repository groups vs. the **official** grouping by MSnLib source SMILES string (`test_molecules_voting.csv`) | **identical** member sets and group sizes (5,002 groups, 57,436 spectra) |
+| repository group strings vs. test-fold source SMILES set | all 5,002 repository strings are source SMILES strings of the test fold |
+| repository groups vs. grouping by RDKit canonical isomeric SMILES | **not identical**: the canonical grouping merges 114 of the repository groups into 4,888 chemically identical molecules |
+
+This is the only definition difference found; it is documented in §7 and in
+`REPORT.json` → `anomalies`.
+
+### 5.4 Retention-time export
+
+`msnlib_rt.csv.gz` was exported from `MSnLib_with_rt.csv` in the data-preparation
+environment. Two files were read in parallel and compared row by row:
+
+| check | result |
+| --- | --- |
+| headers | 7-column `MSnLib.csv` header vs 8-column with-RT header, prefix identical | PASS |
+| rows compared | 560,084 / 560,084 | PASS |
+| first seven columns identical at every row | 0 mismatches | PASS |
+| extra rows at the end of either file | 0 / 0 | PASS |
+| unparsable RT values | 0 / 560,084 | PASS |
+| distinct RT strings | 8,369 (RT is not constant) | PASS |
+
+Because the row order and the first seven columns are identical, `row_index` alone is a
+complete join key to `MSnLib.csv`. The exported table is
+
+`msnlib_rt.csv.gz` — 1,483,069 bytes, SHA-256
+`994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8`, 560,084 data rows,
+columns `row_index,rt`, gzipped only (no plain twin) to keep the package compact.
+
+## 6. Frozen table hashes
+
+SHA-256 of the plain CSV files (the `.csv.gz` twins decompress to exactly these bytes):
+
+| file | rows | bytes | SHA-256 |
+| --- | ---: | ---: | --- |
+| `formula_split.csv` | 21,107 | 424,350 | `fcc44d1996d25306c884a6f8da30c1447fbe74f93c6fa12a3f271c0475a704b8` |
+| `row_formula_fold.csv` | 560,084 | 13,351,630 | `ac6113867fdda683304533f097fc7287c13271a2deac8e792d1316dcf00264ff` |
+| `test_spectra.csv` | 57,437 | 7,751,575 | `f2a870ba8ac9a54a36feaf1ecc12929ad9250ade2d082dc31454028c4b66b548` |
+| `val_spectra.csv` | 55,980 | 7,421,554 | `f4fa5e0f8875991bf9df2bcb67a05437271ee18c317f33d9108f3ec28a887a82` |
+| `test_molecules_voting.csv` | 5,002 | 276,185 | `edad6ec7d6b6f9fc4763deac5245207aee767c78661532621c87acc5a9b1ee07` |
+| `test_molecules_voting_canonical_view.csv` | 4,888 | 269,502 | `9fcd16ff4159e665833ea145848f94bee7c44115f4a858dd75fe486f15e92bd0` |
+
+Gzipped-only companion: `msnlib_rt.csv.gz` — 560,084 rows, 1,483,069 bytes, SHA-256
+`994053612db874f7ac7985f278e04cc3463f3b93cd649a195bd167c4c6c7d3d8`.
+
+## 7. Voting-unit definitions: official 5,002 source-SMILES groups vs 4,888 canonical groups
+
+The **official** multiple-spectrum voting unit is the MSnLib source SMILES string. The test
+fold contains 5,003 distinct source SMILES strings and 4,889 distinct RDKit canonical
+isomeric molecules:
+
+* grouping by the **source SMILES string** gives **5,002 groups** with ≥2 spectra covering
+  **57,436 spectra** (one source string occurs in only one spectrum), and this grouping is
+  **member-for-member identical** to the published repository table that defines
+  `n_molecules = 5002`; it is shipped as `test_molecules_voting.csv`;
+* grouping by **RDKit canonical isomeric SMILES** gives **4,888 groups** covering the same
+  57,436 spectra, leaving exactly one single-spectrum molecule
+  (`CC(C)(C)OC(=O)NCC1(CC(=O)O)CCCCC1`); it is shipped as
+  `test_molecules_voting_canonical_view.csv` and is an **alternative chemical-deduplication
+  view, not the official voting unit**.
+
+The difference is a property of the source library: 114 canonical molecules are written with
+more than one SMILES string among their test spectra. No data was altered to force either
+count.
+
+## 8. Replay from `MSnLib.csv`
+
+`build_split_a.py` replays the complete split (formula computation, frozen fold assignment,
+all six tables) from `MSnLib.csv`. It was run **read-only in the isolated data-preparation environment**
+(RDKit 2026.03.5) without an output directory:
+
+```bash
+python3 build_split_a.py --csv datasets/MSnLib/MSnLib.csv
+```
+
+Result: all 12 count checks passed, all 6 table SHA-256 values matched the frozen files, and
+the script exited 0. Transcript:
+
+```text
+[PASS] n_data_rows: 560,084 (expected 560,084)
+[PASS] n_unique_formula: 21,107 (expected 21,107)
+[PASS] n_formula_train: 16,885 (expected 16,885)
+[PASS] n_formula_val: 2,110 (expected 2,110)
+[PASS] n_formula_test: 2,112 (expected 2,112)
+[PASS] n_spectra_train: 446,667 (expected 446,667)
+[PASS] n_spectra_val: 55,980 (expected 55,980)
+[PASS] n_spectra_test: 57,437 (expected 57,437)
+[PASS] n_voting_groups_official: 5,002 (expected 5,002)
+[PASS] n_voting_spectra_official: 57,436 (expected 57,436)
+[PASS] n_voting_groups_canonical: 4,888 (expected 4,888)
+[PASS] n_voting_spectra_canonical: 57,436 (expected 57,436)
+[PASS] formula_split.csv: 424,350 bytes sha256 fcc44d1996d25306c884a6f8da30c1447fbe74f93c6fa12a3f271c0475a704b8
+[PASS] row_formula_fold.csv: 13,351,630 bytes sha256 ac6113867fdda683304533f097fc7287c13271a2deac8e792d1316dcf00264ff
+[PASS] test_spectra.csv: 7,751,575 bytes sha256 f2a870ba8ac9a54a36feaf1ecc12929ad9250ade2d082dc31454028c4b66b548
+[PASS] val_spectra.csv: 7,421,554 bytes sha256 f4fa5e0f8875991bf9df2bcb67a05437271ee18c317f33d9108f3ec28a887a82
+[PASS] test_molecules_voting.csv: 276,185 bytes sha256 edad6ec7d6b6f9fc4763deac5245207aee767c78661532621c87acc5a9b1ee07
+[PASS] test_molecules_voting_canonical_view.csv: 269,502 bytes sha256 9fcd16ff4159e665833ea145848f94bee7c44115f4a858dd75fe486f15e92bd0
+```
+
+A local replay needs `MSnLib.csv` (752,707,651 bytes, SHA-256 as in §2) and RDKit
+2026.03.5. With a different RDKit patch release, the tables that carry canonical
+strings can differ textually while every count above still matches; the script reports that
+as a `DIFF` with an explanatory message (or a warning under `--lenient-rdkit`) and the
+formula tables are unaffected.
+
+## 9. Simple structural checks
+
+```bash
+# rows
+wc -l formula_split.csv row_formula_fold.csv test_spectra.csv val_spectra.csv \
+      test_molecules_voting.csv test_molecules_voting_canonical_view.csv
+# 21108 / 560085 / 57438 / 55981 / 5003 / 4889  (incl. header)
+# gzip -dc msnlib_rt.csv.gz | wc -l   -> 560085 (incl. header)
+
+# csv.gz twins are byte-identical after decompression
+for f in *.csv; do cmp <(gzip -dc "$f.gz") "$f" || echo "MISMATCH $f"; done
+
+# formula-level uniqueness
+python3 - <<'PY'
+import csv, collections
+fold = {}
+for r in csv.DictReader(open("formula_split.csv")):
+    fold[r["formula"]] = r["fold"]
+print(len(fold), collections.Counter(fold.values()))
+PY
+```
+
+## 10. What could not be verified from this directory alone
+
+* The actual peak arrays (`mzs`/`intensities`) are not shipped; they live in `MSnLib.csv`.
+  The row pointers and the row → formula → fold mapping in `row_formula_fold.csv` are the
+  authoritative link back to the spectra.
+* The exact physical row order of `MSnLib.csv` (which follows the frozen UltraMS conversion
+  of the MSnLib release records); the package depends on the row pointers, not on
+  reconstructing that order from the release files.
+* The historical Figure-3 analysis artifacts themselves; only the published repository
+  voting-group table was cross-checked (§5.3).
+
+## 11. Version
+
+Split A release `1.0.0`, generated 2026-11-04. Any change to the tables, the fold
+assignment or the formula computation invalidates the hashes above and requires a new
+version directory.

split_A_full_msnlib/build_split_a.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""Replay the frozen UltraMS MSnLib formula-level split (split A) from MSnLib.csv.
+
+The split is defined by one rule: **every spectrum of a molecular formula belongs to
+exactly one fold**.  The official multiple-spectrum voting unit is the MSnLib source SMILES
+string: 5,002 groups covering 57,436 of the 57,437 test spectra.  The fold of each formula is the frozen assignment carried by the
+`fold` column of `MSnLib.csv` (560,084 spectra, 21,107 molecular formulas), and the
+per-fold counts are 16,885 / 2,110 / 2,112 formulas and 446,667 / 55,980 / 57,437
+spectra for train / validation / test.  This script recomputes the formula of every
+spectrum with RDKit, verifies that the fold is formula-consistent, rebuilds the shipped
+tables in memory and compares their SHA-256 with the frozen values.  With
+`--output-dir` it also writes the tables.
+
+Usage
+-----
+    # read-only replay + hash check (nothing written):
+    python3 build_split_a.py --csv /path/to/workspace/datasets/MSnLib/MSnLib.csv
+
+    # same, and write the tables:
+    python3 build_split_a.py --csv ... --output-dir replay_split_a
+
+Requirements: Python >= 3.10 and RDKit 2026.03.5 (the frozen canonicalisation runtime).
+Other RDKit patch releases can serialise the same molecule differently; use
+`--lenient-rdkit` to downgrade the resulting table-hash mismatches to warnings.
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import csv
+import hashlib
+import io
+import json
+import sys
+
+from rdkit import Chem, RDLogger
+from rdkit.Chem import rdMolDescriptors
+
+RDLogger.DisableLog("rdApp.*")
+csv.field_size_limit(10**9)
+
+FOLD_ORDER = ["train", "val", "test"]
+
+SOURCE_CSV_SHA256 = "be54b33039cf18675751ea3c6354b592177c899a0cd5df303ae616330133ec07"
+EXPECTED = {
+    "n_data_rows": 560084,
+    "n_unique_formula": 21107,
+    "n_formula_train": 16885,
+    "n_formula_val": 2110,
+    "n_formula_test": 2112,
+    "n_spectra_train": 446667,
+    "n_spectra_val": 55980,
+    "n_spectra_test": 57437,
+    "n_voting_groups_official": 5002,
+    "n_voting_spectra_official": 57436,
+    "n_voting_groups_canonical": 4888,
+    "n_voting_spectra_canonical": 57436,
+}
+FROZEN = {
+    "formula_split.csv": (424350, "fcc44d1996d25306c884a6f8da30c1447fbe74f93c6fa12a3f271c0475a704b8"),
+    "row_formula_fold.csv": (13351630, "ac6113867fdda683304533f097fc7287c13271a2deac8e792d1316dcf00264ff"),
+    "test_spectra.csv": (7751575, "f2a870ba8ac9a54a36feaf1ecc12929ad9250ade2d082dc31454028c4b66b548"),
+    "val_spectra.csv": (7421554, "f4fa5e0f8875991bf9df2bcb67a05437271ee18c317f33d9108f3ec28a887a82"),
+    "test_molecules_voting.csv": (276185, "edad6ec7d6b6f9fc4763deac5245207aee767c78661532621c87acc5a9b1ee07"),
+    "test_molecules_voting_canonical_view.csv": (269502, "9fcd16ff4159e665833ea145848f94bee7c44115f4a858dd75fe486f15e92bd0"),
+}
+CANONICAL_DEPENDENT = {"test_spectra.csv", "val_spectra.csv", "test_molecules_voting.csv",
+                       "test_molecules_voting_canonical_view.csv"}
+
+
+def sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def compute(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None, None
+    return rdMolDescriptors.CalcMolFormula(mol), Chem.MolToSmiles(mol)
+
+
+def replay(csv_path: str):
+    cache = {}
+    bad = []
+    bad_folds = collections.Counter()
+    fold_counts = collections.Counter()
+    formula_spectra = collections.Counter()
+    formula_folds = collections.defaultdict(set)
+    fold_formulas = collections.defaultdict(set)
+    formula_rows = []
+    test_rows = []
+    val_rows = []
+
+    with open(csv_path, newline="") as fh:
+        reader = csv.reader(fh)
+        header = next(reader)
+        col = {name: i for i, name in enumerate(header)}
+        for row_index, row in enumerate(reader):
+            smiles = row[col["smiles"]]
+            fold = row[col["fold"]]
+            if smiles not in cache:
+                cache[smiles] = compute(smiles)
+            formula, canon = cache[smiles]
+            if formula is None:
+                bad.append({"row_index": row_index, "smiles": smiles})
+                continue
+            if fold not in FOLD_ORDER:
+                bad_folds[fold] += 1
+            fold_counts[fold] += 1
+            formula_spectra[formula] += 1
+            formula_folds[formula].add(fold)
+            fold_formulas[fold].add(formula)
+            formula_rows.append((row_index, formula, fold))
+            if fold in ("test", "val"):
+                target = test_rows if fold == "test" else val_rows
+                target.append((row_index, smiles, row[col["precursor_mz"]], row[col["adduct"]],
+                               row[col["collision_energy"]], fold, canon))
+        n_rows = len(formula_rows) + len(bad)
+
+    conflicts = {f: sorted(s) for f, s in formula_folds.items() if len(s) > 1}
+
+    # ---- tables (byte-identical to the frozen files) ----
+    fold_rank = {f: i for i, f in enumerate(FOLD_ORDER)}
+    buf = io.StringIO()
+    w = csv.writer(buf, lineterminator="\n")
+    w.writerow(["formula", "fold", "n_spectra"])
+    for formula, n in sorted(
+        formula_spectra.items(), key=lambda kv: (fold_rank.get(sorted(formula_folds[kv[0]])[0], 99), kv[0])
+    ):
+        w.writerow([formula, sorted(formula_folds[formula])[0], n])
+    tables = {"formula_split.csv": buf.getvalue()}
+
+    buf = io.StringIO()
+    w = csv.writer(buf, lineterminator="\n")
+    w.writerow(["row_index", "formula", "fold"])
+    for row_index, formula, fold in formula_rows:
+        w.writerow([row_index, formula, fold])
+    tables["row_formula_fold.csv"] = buf.getvalue()
+
+    def spectra_csv(rows):
+        buf = io.StringIO()
+        w = csv.writer(buf, lineterminator="\n")
+        w.writerow(["row_index", "smiles", "precursor_mz", "adduct", "collision_energy", "fold",
+                    "canonical_isomeric_smiles"])
+        for r in rows:
+            w.writerow([r[0], r[1], r[2], r[3], r[4], r[5], r[6]])
+        return buf.getvalue()
+
+    tables["test_spectra.csv"] = spectra_csv(test_rows)
+    tables["val_spectra.csv"] = spectra_csv(val_rows)
+
+    canon_groups = collections.Counter(r[6] for r in test_rows)
+    canon_ge2 = sorted((k, v) for k, v in canon_groups.items() if v >= 2)
+    buf = io.StringIO()
+    w = csv.writer(buf, lineterminator="\n")
+    w.writerow(["group_id", "canonical_isomeric_smiles", "n_spectra"])
+    for group_id, (canon, n) in enumerate(canon_ge2):
+        w.writerow([group_id, canon, n])
+    tables["test_molecules_voting_canonical_view.csv"] = buf.getvalue()
+
+    smiles_groups = collections.Counter(r[1] for r in test_rows)
+    smiles_ge2 = sorted((k, v) for k, v in smiles_groups.items() if v >= 2)
+    buf = io.StringIO()
+    w = csv.writer(buf, lineterminator="\n")
+    w.writerow(["group_id", "smiles", "n_spectra"])
+    for group_id, (smiles, n) in enumerate(smiles_ge2):
+        w.writerow([group_id, smiles, n])
+    tables["test_molecules_voting.csv"] = buf.getvalue()
+
+    summary = {
+        "n_data_rows": n_rows,
+        "n_unique_formula": len(formula_spectra),
+        "n_formula_by_fold": {f: len(fold_formulas[f]) for f in FOLD_ORDER},
+        "n_spectra_by_fold": {f: fold_counts[f] for f in FOLD_ORDER},
+        "n_formula_with_multiple_folds": len(conflicts),
+        "formula_conflicts": conflicts,
+        "n_rdkit_parse_failures": len(bad),
+        "parse_failure_examples": bad[:5],
+        "unexpected_folds": dict(bad_folds),
+        "n_voting_groups_official": len(smiles_ge2),
+        "n_voting_spectra_official": sum(n for _, n in smiles_ge2),
+        "n_voting_groups_canonical": len(canon_ge2),
+        "n_voting_spectra_canonical": sum(n for _, n in canon_ge2),
+    }
+    return tables, summary
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--csv", required=True, help="path to MSnLib.csv (560,084 data rows)")
+    parser.add_argument("--output-dir", default=None, help="write the tables here")
+    parser.add_argument("--lenient-rdkit", action="store_true",
+                        help="downgrade canonical-string hash mismatches caused by a different RDKit release to warnings")
+    args = parser.parse_args()
+
+    digest = hashlib.sha256()
+    with open(args.csv, "rb") as fh:
+        while block := fh.read(8 << 20):
+            digest.update(block)
+    source_sha = digest.hexdigest()
+    print(f"source csv : {args.csv}")
+    print(f"source sha : {source_sha}")
+    if source_sha != SOURCE_CSV_SHA256:
+        print(f"[WARN] source SHA-256 differs from the frozen MSnLib.csv ({SOURCE_CSV_SHA256})")
+
+    tables, summary = replay(args.csv)
+
+    failures = []
+    actuals = {
+        "n_data_rows": summary["n_data_rows"],
+        "n_unique_formula": summary["n_unique_formula"],
+        "n_formula_train": summary["n_formula_by_fold"]["train"],
+        "n_formula_val": summary["n_formula_by_fold"]["val"],
+        "n_formula_test": summary["n_formula_by_fold"]["test"],
+        "n_spectra_train": summary["n_spectra_by_fold"]["train"],
+        "n_spectra_val": summary["n_spectra_by_fold"]["val"],
+        "n_spectra_test": summary["n_spectra_by_fold"]["test"],
+        "n_voting_groups_official": summary["n_voting_groups_official"],
+        "n_voting_spectra_official": summary["n_voting_spectra_official"],
+        "n_voting_groups_canonical": summary["n_voting_groups_canonical"],
+        "n_voting_spectra_canonical": summary["n_voting_spectra_canonical"],
+    }
+    for key, expected in EXPECTED.items():
+        actual = actuals[key]
+        ok = actual == expected
+        print(f"[{'PASS' if ok else 'FAIL'}] {key}: {actual:,} (expected {expected:,})")
+        if not ok:
+            failures.append(key)
+    if summary["n_formula_with_multiple_folds"]:
+        print(f"[FAIL] {summary['n_formula_with_multiple_folds']} formulas occur in more than one fold")
+        failures.append("formula_fold_consistency")
+    if summary["n_rdkit_parse_failures"]:
+        print(f"[FAIL] {summary['n_rdkit_parse_failures']} SMILES could not be parsed")
+        failures.append("rdkit_parse")
+    if summary["unexpected_folds"]:
+        print(f"[FAIL] unexpected fold labels: {summary['unexpected_folds']}")
+        failures.append("unexpected_folds")
+
+    canonical_diffs = []
+    for name, (expected_bytes, expected_sha) in FROZEN.items():
+        data = tables[name].encode()
+        got_sha = sha256(data)
+        ok = len(data) == expected_bytes and got_sha == expected_sha
+        print(f"[{'PASS' if ok else 'DIFF'}] {name}: {len(data):,} bytes sha256 {got_sha}")
+        if not ok:
+            if name in CANONICAL_DEPENDENT:
+                canonical_diffs.append(name)
+            else:
+                failures.append(name)
+
+    if args.output_dir:
+        import os
+        os.makedirs(args.output_dir, exist_ok=True)
+        for name, text in tables.items():
+            with open(os.path.join(args.output_dir, name), "w", newline="") as fh:
+                fh.write(text)
+        print(f"wrote {len(tables)} tables to {args.output_dir}")
+
+    print("\nsummary:")
+    print(json.dumps(summary, indent=2))
+
+    if canonical_diffs:
+        message = ("canonical-string tables differ from the frozen copies; the frozen tables were produced with "
+                   "RDKit 2026.03.5 and a different patch release may serialise the same molecule differently")
+        if args.lenient_rdkit:
+            print(f"[WARN] {message}: {', '.join(canonical_diffs)}")
+        else:
+            print(f"[FAIL] {message}: {', '.join(canonical_diffs)}")
+            failures.extend(canonical_diffs)
+
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

split_A_full_msnlib/formula_split.csv.gz

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

split_A_full_msnlib/msnlib_rt.csv.gz

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

split_A_full_msnlib/row_formula_fold.csv

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

split_A_full_msnlib/row_formula_fold.csv.gz

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

split_A_full_msnlib/test_molecules_voting.csv.gz

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