Drop 2 lemat triplets with broken forces; update metadata, docs, notebook, scripts

- lemat/train/lemat_train_0213 and lemat_train_0479 hold 49,999 triplets each. The triplets with saddle ms_id 35584423 and 79800988 (max |F| at the saddle 4.78e11 and 1.02e8 eV/A) are left out. Every other row is byte-identical to its source row.
- metadata/triplets.parquet: 33,877,257 triplets.
- metadata/removed_duplicates.parquet: new column `reason` (duplicate or broken) and 2 rows for the broken triplets.
- README.md, DATASHEET.md: counts and text of this release, citation title.
- example.ipynb: lookup by ms_id; shards open read-only.
- scripts/dedup: the scripts write this release.

DATASHEET.md

@@ -30,19 +30,18 @@ consecutive instances (rows) within an `.aselmdb` file form one
 transition-state event: reactant minimum → first-order saddle / transition
 state → product minimum, all at the
 [`uma-s-1p2`](https://github.com/facebookresearch/fairchem) ML-potential
-level. The dataset (v2) contains 33,877,259 such triplets
-(101,631,777 individual structures), after removing 258,338 duplicate
-triplets from the 34,135,597 of v1.
+level. The dataset contains 33,877,257 such triplets
+(101,631,771 individual structures).
 
 **How many instances are there in total?**
 
-| Subset    | Source                                | Method   | # transition states (v2) | removed duplicates | # `.aselmdb` files |
-|-----------|----------------------------------------|----------|-------------------------:|-------------------:|-------------------:|
-| `lemat/`  | LeMat-Bulk                            | Dimer    | 31,322,917               | 23,502             | 628                |
-| `oc20/`   | Open Catalyst 2020                    | Dimer    | 2,367,718                | 219,383            | 49                 |
-| `oc22/`   | Open Catalyst 2022                    | Dimer    | 152,593                  | 14,742             | 5                  |
-| `mp20bat/`| Materials Project battery structures  | NEB-CI   | 34,031                   | 711                | 3                  |
-| **Total** |                                       |          | **33,877,259**           | **258,338**        | **685**            |
+| Subset    | Source                                | Method   | # transition states      | # `.aselmdb` files |
+|-----------|----------------------------------------|----------|-------------------------:|-------------------:|
+| `lemat/`  | LeMat-Bulk                            | Dimer    | 31,322,915               | 628                |
+| `oc20/`   | Open Catalyst 2020                    | Dimer    | 2,367,718                | 49                 |
+| `oc22/`   | Open Catalyst 2022                    | Dimer    | 152,593                  | 5                  |
+| `mp20bat/`| Materials Project battery structures  | NEB-CI   | 34,031                   | 3                  |
+| **Total** |                                       |          | **33,877,257**           | **685**            |
 
 **Does the dataset contain all possible instances or is it a sample
 (including a probabilistic sample) from a larger set?**
@@ -85,18 +84,12 @@ it themselves from the atomic geometry.
 **Are relationships between individual instances made explicit?**
 Within a single triplet, the three rows are stored consecutively (ASE row
 ids `3k+1`, `3k+2`, `3k+3` of a file; `ms_id`s `3m`, `3m+1`, `3m+2`) and share
-`src_index`. Since v2, duplicate triplets are removed: triplets whose saddle,
-reactant and product all agree within 0.2 Å max-atom distance (same
-composition and lattice; reactant/product in either orientation) are merged,
-keeping the lowest `ms_id`. `metadata/removed_duplicates.parquet` maps every
-removed triplet to the one kept. Triplets that share a saddle but connect
-different endpoints are distinct reactions and are kept; triplets that share
-an upstream input structure are related through `source_id` in
-`metadata/triplets.parquet`.
+`src_index`. Triplets that share an upstream input structure are related
+through `source_id` in `metadata/triplets.parquet`.
 
 **Are there recommended data splits (e.g., training, development/validation,
 testing)?**
-Yes — since v2 the data are stored already split, as `<subset>/train/`,
+Yes — the data are stored already split, as `<subset>/train/`,
 `<subset>/val/` and `<subset>/test/`. Whole chemical systems (element sets)
 were assigned to train / val / test with probabilities 0.90 / 0.05 / 0.05
 (seed 0), globally across subsets, so no chemical system — and hence no
@@ -114,10 +107,8 @@ Custom splits should be chosen with care for the downstream task — see
 - *Convergence threshold residuals*: structures meet `max|F| < 0.05 eV/Å`
   (saddle) and `< 0.02 eV/Å` (endpoints) but are not strictly at zero force.
 - *Multiple saddle searches per input*: the same input structure is
-  typically attempted with several initialization moves. Exact repeats
-  (saddle and both endpoints within 0.2 Å) are removed in v2; saddles that
-  are geometrically similar but further apart, or that connect different
-  endpoints, remain.
+  typically attempted with several initialization moves. The saddles from
+  one input can be geometrically similar or connect different endpoints.
 - *Eigenmode quality*: the eigenmode is the converged Dimer rotation
   direction (Dimer subset) or the NEB tangent at the climbing image
   (NEB subset). Both are good first-order approximations to the unstable
@@ -189,17 +180,16 @@ Yes. The release pipeline:
    (`is_reaction`, `n_formed_bonds`, `n_broken_bonds`, …) are recorded on
    dimer rows but are not the gating filter.
 4. Compute a `uma-s-1p2` single-point energy and forces for every row.
-5. (v2) Remove duplicate triplets and write the chemical-system-disjoint
-   split as `<subset>/<split>/<subset>_<split>_<NNNN>.aselmdb` files in
-   `ms_id` order, copying every row byte-for-byte from v1.
+5. Write the chemical-system-disjoint split as
+   `<subset>/<split>/<subset>_<split>_<NNNN>.aselmdb` files in `ms_id` order.
+   Copy every row byte-for-byte from the files of step 4.
 
 **Was the "raw" data saved in addition to the preprocessed data?**
 Internally yes; not part of this public release.
 
 **Is the software used to preprocess/clean/label the instances available?**
 Yes — [SaddleMill](https://github.com/SciLM-ai/SaddleMill) is open
-source. The scripts that produced v2 from v1 (deduplication, split, rewrite
-and verification) are included under `scripts/dedup/`.
+source.
 
 ## Uses
 
@@ -263,8 +253,8 @@ Yes — public release on Hugging Face at
 
 **How will the dataset be distributed?**
 Hugging Face Hub, as `.aselmdb` files in `<subset>/<split>/` directories,
-plus this `DATASHEET.md`, `README.md`, an example notebook, the `metadata/`
-tables and the `scripts/dedup/` reproduction scripts. ASE-LMDB lock
+plus this `DATASHEET.md`, `README.md`, an example notebook and the
+`metadata/` tables. ASE-LMDB lock
 artifacts (`*.aselmdb-lock`) are excluded via `.gitignore`.
 
 **When will the dataset be distributed?**
@@ -295,9 +285,7 @@ Ilgar Baghishov (<baghishov@utexas.edu>) and Sung Hoon Jung
 (<sunghjung3@utexas.edu>), or open a discussion on the Hugging Face Hub page.
 
 **Is there an erratum?**
-v2 supersedes v1: v1 contained 258,338 duplicate triplets (0.76 %; 8–9 % of
-`oc20`/`oc22`) and a random split in which most test chemistry also occurred
-in training. See the README changelog.
+No.
 
 **Will the dataset be updated?**
 Future releases may (a) add DFT single-point energies/forces on a
@@ -324,9 +312,6 @@ Open a discussion / pull request on the Hugging Face Hub repository.
   hold-out (e.g. by host material regardless of adsorbate, or by upstream
   structure), build it from `metadata/triplets.parquet`
   (`chemical_system`, `reduced_formula`, `source_id`).
-- **Near-duplicates beyond 0.2 Å remain.** v2 removes exact repeats only;
-  closely related saddles from the same input structure can still occur
-  within a split.
 - **Don't compare absolute barriers across subsets** without recomputing —
   the `barrier` field is stored only for the NEB (`mp20bat`) subset and
   is at the `uma-s-1p2` level, not DFT.

README.md

@@ -26,7 +26,7 @@ tags:
 > Hub URL: <https://huggingface.co/datasets/SciLM/MaterialsSaddles>
 > Released by SciLM.ai: <https://www.scilm.ai>
 
-**33,877,259 unique, fully converged transition states** computed by
+**33,877,257 fully converged transition states** computed by
 massively-parallel saddle searches on top of public materials and catalysis
 datasets, using the [SaddleMill](https://github.com/SciLM-ai/SaddleMill)
 package and Meta's [`uma-s-1p2`](https://github.com/facebookresearch/fairchem)
@@ -39,10 +39,9 @@ saddles to 0.05 eV/Å. Every row stores its `uma-s-1p2` **energy and forces**,
 and each saddle row also stores its **eigenmode** — an `(N, 3)` per-atom
 displacement field giving the direction along which the saddle is unstable.
 
-**Version 2** (this version) removes duplicate transition states and ships the
-data already split into `train/`, `val/` and `test/` directories, with **no
-chemical system (element set) shared between the three splits**. See
-[What changed in v2](#what-changed-in-v2).
+The files are already divided into `train/`, `val/` and `test/` directories, with
+**no chemical system (element set) shared between the three splits**. See
+[Train / val / test](#train--val--test).
 
 ---
 
@@ -50,8 +49,7 @@ chemical system (element set) shared between the three splits**. See
 
 | | |
 |---|---|
-| Transition states (unique)             | **33,877,259** |
-| Duplicates removed from v1             | 258,338 (0.76 %) |
+| Transition states                      | **33,877,257** |
 | Files (`.aselmdb`)                     | 685 (at most 50,000 transition states each) |
 | Rows per TS                            | 3 (reactant, saddle, product), in order |
 | Split                                  | train / val / test ≈ 90 / 5 / 5, disjoint in chemical system |
@@ -65,40 +63,11 @@ chemical system (element set) shared between the three splits**. See
 
 | Subset    | Source                                      | Method | # transition states | train      | val       | test      | Files |
 |-----------|---------------------------------------------|--------|--------------------:|-----------:|----------:|----------:|------:|
-| `lemat/`  | LeMat-Bulk                                  | Dimer  | 31,322,917          | 28,223,516 | 1,533,392 | 1,566,009 | 628   |
+| `lemat/`  | LeMat-Bulk                                  | Dimer  | 31,322,915          | 28,223,514 | 1,533,392 | 1,566,009 | 628   |
 | `oc20/`   | Open Catalyst 2020 (OC20)                   | Dimer  | 2,367,718           | 2,133,114  | 123,751   | 110,853   | 49    |
 | `oc22/`   | Open Catalyst 2022 (OC22)                   | Dimer  | 152,593             | 139,175    | 6,557     | 6,861     | 5     |
 | `mp20bat/`| Materials Project battery structures        | NEB-CI | 34,031              | 31,046     | 1,454     | 1,531     | 3     |
-| **Total** |                                             |        | **33,877,259**      | **30,526,851** | **1,665,154** | **1,685,254** | **685** |
-
----
-
-## What changed in v2
-
-1. **Duplicates removed.** A transition state is a duplicate of another when
-   they have the same composition and lattice and the saddle, the reactant and
-   the product all agree to within 0.2 Å max-atom distance (reactant and product
-   compared in either orientation). One representative per group is kept (the
-   lowest `ms_id`); 258,338 triplets were removed — 23,502 from `lemat`
-   (0.07 %), 219,383 from `oc20` (8.48 %), 14,742 from `oc22` (8.81 %) and 711
-   from `mp20bat` (2.05 %). See [Deduplication](#deduplication).
-2. **New split, disjoint in chemical system.** The v1 split was a random
-   90 / 5 / 5 split of triplets; 94–100 % of its test triplets had a chemical
-   system also present in train, and 60–100 % had the exact same reduced
-   formula. In v2 every chemical system is assigned as a whole to one split,
-   globally across all four subsets. See [Train / val / test](#train--val--test).
-3. **The split is physical.** Each subset directory holds `train/`, `val/` and
-   `test/` subdirectories; no manifest lookup is needed to select a split.
-   (v1's `splits/*.parquet` manifests are removed.)
-4. **Files are in `ms_id` order.** Within each split directory, files and the
-   rows inside them follow ascending `ms_id`; the three rows of a triplet are
-   adjacent. File names are `<subset>_<split>_<NNNN>.aselmdb`.
-5. **Rows are unchanged.** Every row is copied byte-for-byte from v1 (same
-   geometry, energy, forces, `info`, and `ms_id`); only which rows are present
-   and in which file changed. `ms_id`s of removed triplets are simply absent, so
-   `ms_id` is no longer contiguous.
-
-v1 remains available in the repository's commit history.
+| **Total** |                                             |        | **33,877,257**      | **30,526,849** | **1,665,154** | **1,685,254** | **685** |
 
 ---
 
@@ -145,15 +114,17 @@ jupyter notebook example.ipynb
 │   ├── train/  mp20bat_train_0000.aselmdb
 │   ├── val/    mp20bat_val_0000.aselmdb
 │   └── test/   mp20bat_test_0000.aselmdb
-├── metadata/
-│   ├── triplets.parquet               (one row per transition state: ms_id → file, row, split, chemistry, source)
-│   └── removed_duplicates.parquet     (one row per removed triplet → the triplet kept in its place)
-└── scripts/
-    └── dedup/                         (the exact scripts that produced v2, with a README)
+└── metadata/
+    └── triplets.parquet               (one row per transition state: ms_id → file, row, split, chemistry, source)
 ```
 
-Every file holds at most 50,000 transition states (150,000 rows); all but the
-last file of each split directory hold exactly 50,000.
+Every file holds at most 50,000 transition states (150,000 rows). In each split
+directory, every file but the last holds exactly 50,000. The exceptions are
+`lemat/train/lemat_train_0213.aselmdb` and `lemat/train/lemat_train_0479.aselmdb`,
+with 49,999 each.
+
+Within each split directory, files and the rows inside them follow ascending
+`ms_id`.
 
 ---
 
@@ -204,7 +175,7 @@ target subset.
 | `is_ads_reaction`, `n_ads_*`, `ads_*_bonds` | dimer rows | adsorbate-restricted bond changes |
 | `parent_ts_index`            | dimer endpoints | upstream SaddleMill identifier of the parent saddle (an internal pointer; the saddle in the same triplet is the immediately adjacent row in this `.aselmdb` file) |
 | `src_index`                  | all rows | SaddleMill internal ID (file-local in the production run) |
-| `ms_id`                      | all rows | global row identifier across the **entire dataset**, unchanged from v1 (0..102,406,790; the ids of removed duplicates are absent). Triplets occupy three consecutive `ms_id`s: `3k` (reactant), `3k+1` (saddle), `3k+2` (product). |
+| `ms_id`                      | all rows | global row identifier across the **entire dataset** (0..102,406,790, with gaps). Triplets occupy three consecutive `ms_id`s: `3k` (reactant), `3k+1` (saddle), `3k+2` (product). |
 | `task_name`                  | all rows | UMA task head used during the saddle search and for the stored energy/forces: `"omat"` for `lemat` and `mp20bat`, `"oc20"` for `oc20`, `"oc22"` for `oc22`. |
 | `status`                     | all rows | SaddleMill run status (always a `converged*` value here) |
 | `orig_info`                  | all rows | nested dict; carries the **source-dataset identifiers** (see below) |
@@ -360,39 +331,6 @@ The split lives in the directory layout: `<subset>/train/`, `<subset>/val/`,
   [Quick stats](#breakdown-by-source-dataset)); they deviate slightly because
   whole chemical systems are assigned together.
 
-For comparison, the v1 random split had 94–100 % of test transition states in
-a chemical system that also occurs in training, and 60–100 % with the exact
-same reduced formula.
-
----
-
-## Deduplication
-
-Two transition states are duplicates when all of the following hold:
-
-- identical composition (same atoms, same counts);
-- the same lattice: cell lengths within 2 %, angles within 1°, and every
-  cell-matrix entry within 2 % of the longest cell vector;
-- saddle max-atom distance < 0.2 Å;
-- reactant and product both < 0.2 Å max-atom distance, in the same or in the
-  swapped (reactant ↔ product) orientation.
-
-The max-atom distance is the largest displacement of any atom after an optimal
-per-species atom matching (Hungarian assignment) under the minimum-image
-convention, with fractional coordinates mapped into the mean of the two cells.
-Candidates are compared across all four subsets. Within each composition,
-transition states are processed in `ms_id` order and each joins the first
-earlier kept transition state it duplicates (leader clustering); the kept
-representative of every group is its lowest `ms_id`.
-
-Audits of the result: all 2,992 removed triplets re-checked with an
-independent implementation match their representative; in 2,000 kept triplets
-compared against *every* transition state of the same composition, no missed
-duplicate was found. No duplicate group spans two subsets.
-
-[`metadata/removed_duplicates.parquet`](#metadata) lists every removed
-triplet and the triplet kept in its place, so v1 results can be mapped to v2.
-
 ---
 
 ## Metadata
@@ -410,21 +348,6 @@ sorted by `saddle_ms_id`:
 | `reduced_formula` | composition divided by its greatest common divisor |
 | `source_id` | upstream identifier: LeMat-Bulk `immutable_id`; OC20 `source_file`; OC22 `sid`; Materials Project `charge_id|discharge_id|working_ion` |
 
-`metadata/removed_duplicates.parquet` — one row per removed triplet:
-`removed_saddle_ms_id`, `removed_subset`, `kept_saddle_ms_id`, `kept_subset`.
-
----
-
-## Reproducing v2
-
-[`scripts/dedup/`](./scripts/dedup/) contains the exact scripts, run in the
-order given in its README: duplicate detection (three passes), the split, the
-byte-for-byte rewrite of the v1 files into this layout, and the verification
-that every released row is identical to its v1 row, that each split directory
-holds exactly the transition states of its split, and that no removed
-duplicate is present. Paths inside the scripts are those of the original run
-and have to be adapted.
-
 ---
 
 ## How the data was produced
@@ -476,9 +399,6 @@ and forces of every row were then computed with a `uma-s-1p2` single point.
   guaranteed on every row. NEB-derived rows (e.g. `mp20bat`) have a
   different `info` schema than dimer rows (e.g. no `side`, but
   `image_type` / `image_idx` / `barrier` instead).
-- **Deduplication is geometric, at 0.2 Å.** Transition states closer than
-  that in saddle *and* both endpoints are merged; pairs that share a saddle
-  but connect different endpoints are distinct reactions and are kept.
 
 ---
 
@@ -488,7 +408,7 @@ If you use this dataset, please cite:
 
 ```bibtex
 @misc{materialssaddles2026,
-  title        = {{MaterialsSaddles}: [N] Million Transition States and a Flow-Matching
+  title        = {{MaterialsSaddles}: 33.9 Million Transition States and a Flow-Matching
                   Saddle-Point Predictor for Materials},
   author       = {Baghishov, Ilgar and Jung, Sung Hoon and Henkelman, Graeme},
   year         = {2026},
@@ -567,16 +487,6 @@ International (CC-BY-4.0)](https://creativecommons.org/licenses/by/4.0/).
 The upstream datasets retain their own licenses; consult them before any
 redistribution that combines this dataset with theirs.
 
-## Changelog
-
-- **v2** — duplicates removed (258,338 triplets; 33,877,259 remain); new
-  train / val / test split disjoint in chemical system, stored as
-  `<subset>/{train,val,test}/` directories of files in `ms_id` order; every
-  row carries `uma-s-1p2` energy and forces; `metadata/` tables and the
-  reproduction scripts added. Row contents are byte-identical to v1.
-- **v1** — initial public release (34,135,597 transition states, random
-  90 / 5 / 5 split given as `ms_id` manifests).
-
 ## Contact
 
 Maintainers: Ilgar Baghishov (<baghishov@utexas.edu>) and Sung Hoon Jung

example.ipynb

@@ -54,8 +54,10 @@
     "import os\n",
     "from pathlib import Path\n",
     "\n",
+    "import fsspec\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
+    "import pyarrow.parquet as pq\n",
     "from ase.db import connect\n",
     "from ase.visualize.plot import plot_atoms\n",
     "from huggingface_hub import HfApi, hf_hub_download\n",
@@ -72,7 +74,20 @@
     "    \"\"\"\n",
     "    atoms = row.toatoms()\n",
     "    atoms.info.update(row.data[\"info\"])\n",
-    "    return atoms\n"
+    "    return atoms\n",
+    "\n",
+    "_SHARDS = {}\n",
+    "\n",
+    "def open_shard(path):\n",
+    "    \"\"\"\n",
+    "    Open an .aselmdb file read-only, once per process. LMDB refuses a second open of\n",
+    "    the same file, so the notebook cells share this one connection.\n",
+    "    \"\"\"\n",
+    "    path = os.path.realpath(path)\n",
+    "    if path not in _SHARDS:\n",
+    "        _SHARDS[path] = connect(path, type=\"aselmdb\", readonly=True)\n",
+    "    return _SHARDS[path]\n",
+    ""
    ]
   },
   {
@@ -119,9 +134,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dbs = {subset: connect(shard_paths[subset], type=\"aselmdb\") for subset in SHARD_FILES}\n",
+    "dbs = {subset: open_shard(shard_paths[subset]) for subset in SHARD_FILES}\n",
     "for subset, db in dbs.items():\n",
-    "    print(f\"  {subset:8s} file: {len(db):>7d} rows  -> {len(db)//3:>6d} triplets\")\n"
+    "    print(f\"  {subset:8s} file: {len(db):>7d} rows  -> {len(db)//3:>6d} triplets\")\n",
+    ""
    ]
   },
   {
@@ -167,6 +183,59 @@
     "print(f\"\\n  saddle energy {row.energy:.4f} eV, max |F| {np.abs(row.forces).max():.4f} eV/A\")\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "9baae3af",
+   "metadata": {},
+   "source": [
+    "## Look up triplets by `ms_id`\n",
+    "\n",
+    "`lookup` returns the R, S and P `Atoms` of the requested triplets, keyed by saddle `ms_id`. It accepts the `ms_id` of any of the three rows, because R and P carry the saddle `ms_id` minus 1 and plus 1.\n",
+    "\n",
+    "The shard (`file`) and the row id of R (`reactant_row_id`) of each triplet are in `metadata/triplets.parquet`. `lookup` reads only these two columns and `saddle_ms_id` from Hugging Face, without a download of the whole 713 MB file. The file is sorted by `saddle_ms_id` in 33 row groups (blocks of about one million triplets), so the filter reads only the groups that can hold the requested ids, at most 119 MB. `lookup` downloads a shard that holds a requested triplet once into `DATA_DIR` (median 1.3 GB, at most 1.6 GB).\n",
+    "\n",
+    "With a local copy of the dataset, pass the local path of `triplets.parquet` as `triplets` and set `DATA_DIR` to the dataset root. An `ms_id` that is not in the dataset is absent from the result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8ef5cf93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lookup(ms_ids, triplets=f\"hf://datasets/{REPO}@{REVISION}/metadata/triplets.parquet\"):\n",
+    "    \"\"\"\n",
+    "    Return {saddle ms_id: [R, S, P]} for the R, S or P ms_ids given.\n",
+    "    `triplets` is the hf:// URL or a local path of metadata/triplets.parquet.\n",
+    "    \"\"\"\n",
+    "    saddle_ids = sorted({3 * (int(m) // 3) + 1 for m in ms_ids})\n",
+    "    fs, path = fsspec.core.url_to_fs(triplets)\n",
+    "    table = pq.read_table(path, filesystem=fs, columns=[\"saddle_ms_id\", \"file\", \"reactant_row_id\"],\n",
+    "                          filters=[(\"saddle_ms_id\", \"in\", saddle_ids)])\n",
+    "    out = {}\n",
+    "    for rec in table.to_pylist():\n",
+    "        local = DATA_DIR / rec[\"file\"]\n",
+    "        if not local.exists():\n",
+    "            hf_hub_download(repo_id=REPO, repo_type=\"dataset\", revision=REVISION,\n",
+    "                            filename=rec[\"file\"], local_dir=str(DATA_DIR))\n",
+    "        db = open_shard(local)\n",
+    "        rows = [db.get(id=rec[\"reactant_row_id\"] + i) for i in range(3)]\n",
+    "        out[rec[\"saddle_ms_id\"]] = [row_to_atoms(row) for row in rows]\n",
+    "    return out\n",
+    "\n",
+    "# One id per subset from the test shards above, so no new shard is downloaded:\n",
+    "# a lemat S id, an oc20 R id, an oc22 P id and an mp20bat S id.\n",
+    "# 888577 is not in the dataset.\n",
+    "ids = [93563983, 101395944, 102040922, 102353293, 888577]\n",
+    "triplets = lookup(ids)\n",
+    "for s, (R, S, P) in triplets.items():\n",
+    "    print(f\"  saddle {s:>9}  {S.get_chemical_formula():<18}  ms_id (R, S, P) = \"\n",
+    "          f\"({R.info['ms_id']}, {S.info['ms_id']}, {P.info['ms_id']})  \"\n",
+    "          f\"E_S - E_R = {S.get_potential_energy() - R.get_potential_energy():.3f} eV\")\n",
+    "print(\"  not found:\", sorted({3 * (m // 3) + 1 for m in ids} - set(triplets)))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "29e0a999",
@@ -289,4 +358,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

lemat/train/lemat_train_0213.aselmdb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a9f7ec598ae231458601702e60d940b4060adeead9326b4a31ebd73aed149064
-size 1303150592
+oid sha256:f3efbbcb5e53908396420e3a90365854686167bcd6963b9b031e18a4f3f0813f
+size 1233076224

lemat/train/lemat_train_0479.aselmdb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e4f6a1531b0577d0e8d305925566a3a245b77763ba209d884ae7246b4e80c785
-size 1286668288
+oid sha256:d62a9ad5d0b9d76a0df38070a8f748d936b4794eefe9203b36ff2a68cac91fa4
+size 1212084224

metadata/removed_duplicates.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:286158fee67642a7c7ec2c603e817b11ef61f95fea33e729853672438abaadcb
-size 1697477
+oid sha256:b2351b305b4c4049cff9ecec1430537a9e5d63a89772e8863691eeb433c26fd2
+size 1698605

metadata/triplets.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fb554866d7ebd803f0fdb447e8dd080ea861edced51ff7f19c5b38df582b7a28
-size 712945644
+oid sha256:5e7d7d08be79fa49d07552aee6dca50d803ca3af5f39768efe7f6b552523d3d3
+size 712979888

scripts/dedup/README.md

@@ -1,6 +1,8 @@
 # How MaterialsSaddles v2 was produced from v1
 
-These are the exact scripts that were run. Absolute paths inside them are those of the original run
+These are the scripts that were run, with one change. We removed the 2 broken triplets of step 7 in a separate
+step after the write. Here, steps 7 to 9 do this removal. The scripts write the same rows and tables as the
+release. Absolute paths inside them are those of the original run
 (`ROOT` = the v1 files, `OUT` = a work directory) and must be adapted. Dependencies: `numpy`, `scipy`,
 `pyarrow`, `ase`, `ase_db_backends`, `lmdb`, `huggingface_hub`; `fairchem-core` only for one check in
 `v2_verify.py`.
@@ -40,11 +42,18 @@ These are the exact scripts that were run. Absolute paths inside them are those
 7. `v2_write.py` — writes `<subset>/<split>/<subset>_<split>_<NNNN>.aselmdb`, at most 50,000 triplets per
    file, in ascending `ms_id` order. Rows are not re-serialised: the stored (compressed JSON) value of each
    row is copied unchanged under the new ASE row id, and `nextid` is written as `ase_db_backends` does.
+   `v2_write.py` cuts the files on the full split lists. Then it skips the 2 broken triplets (saddle `ms_id`
+   35584423 and 79800988, forces at the saddle above 100 million eV/Å). As a result, `lemat_train_0213` and
+   `lemat_train_0479` hold 49,999 triplets each. The other files do not change.
 8. `v2_verify.py` — reads every row of every output file and checks: keys `1..N` + `nextid`; complete,
    adjacent R, S, P triplets in ascending `ms_id` order; every stored value byte-identical to the v1 row
-   with the same `ms_id`; files of a split named consecutively, in `ms_id` order, all but the last full;
-   each split directory holds exactly the `ms_id`s of its split; the union is exactly the kept set; no
-   removed triplet present. It also compares a random sample of rows read through `ase.db` against the v1
+   with the same `ms_id`; files of a split named consecutively, in `ms_id` order, all but the last full
+   (except `lemat_train_0213` and `lemat_train_0479`, each one broken triplet short);
+   each split directory holds exactly the `ms_id`s of its split, less the 2 broken triplets; the union is
+   exactly the kept set, less the 2 broken triplets; no removed or broken triplet present. It also compares a
+   random sample of rows read through `ase.db` against the v1
    rows and opens files with fairchem's `AseDBDataset`.
 9. `v2_metadata.py` — builds `metadata/triplets.parquet` and `metadata/removed_duplicates.parquet` from
    what `v2_verify.py` observed in the written files (refuses to run if verification failed).
+   `removed_duplicates.parquet` lists each removed duplicate with its kept triplet (`reason` = `duplicate`)
+   and the 2 broken triplets with no kept triplet (`reason` = `broken`).

scripts/dedup/v2_claims.py

@@ -16,7 +16,7 @@ print("split totals", {k: int((spl == k).sum()) for k in ("train", "val", "test"
 fold = defaultdict(set); fofold = defaultdict(set)
 for c_, f_, k_ in zip(cs, fo, spl): fold[c_].add(k_); fofold[f_].add(k_)
 print("chemical systems", len(fold), "in >1 split:", sum(len(v) > 1 for v in fold.values()), "| formulas in >1 split:", sum(len(v) > 1 for v in fofold.values()))
-R = pq.read_table(f"{out}/metadata/removed_duplicates.parquet").to_pydict()
+R = pq.read_table(f"{out}/metadata/removed_duplicates.parquet", filters=[("reason", "==", "duplicate")]).to_pydict()   # broken rows: no kept triplet
 rs = np.array(R["removed_subset"]); print("removed", len(rs), {s: int((rs == s).sum()) for s in ["lemat", "oc20", "oc22", "mp20bat"]},
                                           "cross-subset", int((rs != np.array(R["kept_subset"])).sum()))
 print("removed ids in release:", int(np.isin(R["removed_saddle_ms_id"], T["saddle_ms_id"]).sum()), " kept ids all in release:", bool(np.isin(R["kept_saddle_ms_id"], T["saddle_ms_id"]).all()))

scripts/dedup/v2_metadata.py

@@ -3,13 +3,15 @@
   metadata/triplets.parquet   one row per released triplet, sorted by saddle_ms_id:
       saddle_ms_id, subset, split, file, reactant_row_id (ASE id of the reactant row in `file`; saddle = +1,
       product = +2), chemical_system, reduced_formula, source_id
-  metadata/removed_duplicates.parquet   one row per removed triplet:
-      removed_saddle_ms_id, removed_subset, kept_saddle_ms_id, kept_subset
+  metadata/removed_duplicates.parquet   one row per removed triplet, sorted by removed_saddle_ms_id:
+      removed_saddle_ms_id, removed_subset, kept_saddle_ms_id, kept_subset, reason ("duplicate", or "broken" for
+      the BROKEN triplets that v2_write.py leaves out, with null kept_saddle_ms_id and kept_subset)
   usage: v2_metadata.py <observed.npz> <meta_dir> <duplicates.parquet> <out_root>
 """
 import glob, os, sys
 import numpy as np, pyarrow as pa, pyarrow.parquet as pq
 obs, meta_dir, dup_file, out = sys.argv[1:5]; SUBS = ["lemat", "mp20bat", "oc20", "oc22"]
+BROKEN = [35584423, 79800988]                    # saddle ms_ids of the 2 broken triplets that v2_write.py leaves out
 O = np.load(obs); assert bool(O["passed"]), "verification did not pass - refusing to build metadata"
 files, n, ms = O["shard"], O["n"], O["ms"]
 fi = np.repeat(np.arange(len(files)), n); row = np.concatenate([np.arange(1, k + 1) for k in n])
@@ -29,9 +31,13 @@ assert (np.array([SUBS[x] for x in msub[p][t]]) == parts[s_fi[t], 0]).all(), "su
 os.makedirs(f"{out}/metadata", exist_ok=True)
 pq.write_table(tab, f"{out}/metadata/triplets.parquet", compression="zstd")
 D = pq.read_table(dup_file); dms = np.asarray(D.column(0)); drep = np.asarray(D.column(1)); r = dms != drep
-pd_ = np.searchsorted(mms, dms[r]); pk = np.searchsorted(mms, drep[r])
-pq.write_table(pa.table({"removed_saddle_ms_id": pa.array(dms[r], pa.int64()), "removed_subset": pa.array([SUBS[x] for x in msub[pd_]]),
-                         "kept_saddle_ms_id": pa.array(drep[r], pa.int64()), "kept_subset": pa.array([SUBS[x] for x in msub[pk]])}),
-               f"{out}/metadata/removed_duplicates.parquet", compression="zstd")
-assert not np.isin(dms[r], s_ms).any() and np.isin(drep[r], s_ms).all(), "removed/kept inconsistent with the files"
-print(f"triplets.parquet: {tab.num_rows} rows; removed_duplicates.parquet: {int(r.sum())} rows")
+pd_ = np.searchsorted(mms, dms[r]); pk = np.searchsorted(mms, drep[r]); pb = np.searchsorted(mms, BROKEN)
+dup = pa.table({"removed_saddle_ms_id": pa.array(dms[r], pa.int64()), "removed_subset": pa.array([SUBS[x] for x in msub[pd_]]),
+                "kept_saddle_ms_id": pa.array(drep[r], pa.int64()), "kept_subset": pa.array([SUBS[x] for x in msub[pk]]),
+                "reason": pa.array(["duplicate"] * int(r.sum()), pa.string())})
+brk = pa.table({"removed_saddle_ms_id": pa.array(BROKEN, pa.int64()), "removed_subset": pa.array([SUBS[x] for x in msub[pb]]),
+                "kept_saddle_ms_id": pa.array([None] * len(BROKEN), pa.int64()), "kept_subset": pa.array([None] * len(BROKEN), pa.string()),
+                "reason": pa.array(["broken"] * len(BROKEN), pa.string())})
+pq.write_table(pa.concat_tables([dup, brk]).sort_by("removed_saddle_ms_id"), f"{out}/metadata/removed_duplicates.parquet", compression="zstd")
+assert not np.isin(dms[r], s_ms).any() and np.isin(drep[r], s_ms).all() and not np.isin(BROKEN, s_ms).any(), "removed/kept inconsistent with the files"
+print(f"triplets.parquet: {tab.num_rows} rows; removed_duplicates.parquet: {int(r.sum())} duplicate + {len(BROKEN)} broken rows")

scripts/dedup/v2_verify.py

@@ -6,8 +6,10 @@ For EVERY output shard <out>/<subset>/<fold>/*.aselmdb:
     complete triplets (ms % 3 = 0, 1, 2 consecutive);
   * sha1 of every stored value equals the sha1 of the SciLM row with the same ms_id (byte-identical copy).
 Across shards:
-  * every ms_id appears once; per subset/fold the ms_id set equals <split_dir>/<subset>/<fold>.parquet exactly;
-  * the union equals the kept triplets of duplicates.parquet (representative == itself), no removed triplet appears.
+  * every ms_id appears once; per subset/fold the ms_id set equals <split_dir>/<subset>/<fold>.parquet minus the
+    BROKEN triplets exactly;
+  * the union equals the kept triplets of duplicates.parquet (representative == itself) minus BROKEN, no removed or
+    BROKEN triplet appears.
 ASE-level spot check on a random sample: row read with ase.db equals the SciLM row read with ase.db
 (numbers, positions, cell, pbc, constraints, energy, forces, key_value_pairs, data), and every shard opens in
 fairchem's AseDBDataset.
@@ -21,6 +23,10 @@ from ase.io.jsonio import decode, encode
 out, src_root, idx_dir, split_dir, dup_file, meta_dir = sys.argv[1:7]
 per = int(sys.argv[7]) if len(sys.argv) > 7 else 50000; nw = int(sys.argv[8]) if len(sys.argv) > 8 else 48
 SUBS = sys.argv[9].split(",") if len(sys.argv) > 9 else ["lemat", "mp20bat", "oc20", "oc22"]; FOLDS = ["train", "val", "test"]
+# saddle ms_ids of the 2 broken triplets that v2_write.py leaves out, and the files that therefore hold fewer
+# triplets (file name -> triplets left out)
+BROKEN = [35584423, 79800988]
+SHORT = {"lemat_train_0213.aselmdb": 1, "lemat_train_0479.aselmdb": 1}
 
 
 def check_shard(path):
@@ -77,22 +83,24 @@ if __name__ == "__main__":
             ms = np.concatenate([res[p][0] for p in fs]) if fs else np.array([], np.int64)
             raw = np.concatenate([res[p][1] for p in fs]) if fs else np.array([], "S20")
             want = np.sort(np.asarray(pq.read_table(f"{split_dir}/{s}/{f}.parquet").column("ms_id")))
+            want = want[~np.isin(want // 3, np.array(BROKEN) // 3)]
             same = np.array_equal(np.sort(ms), want)
             pos = np.searchsorted(ims, ms); okpos = (pos < len(ims)) & (ims[np.minimum(pos, len(ims) - 1)] == ms)
             bytes_ok = okpos.all() and bool((iraw[pos] == raw).all())
             # shards of a fold: named _0000.._NNNN, consecutive ms_id ranges in name order, all but the last full
+            # (a file in SHORT holds per minus its removed triplets)
             names_ok = [os.path.basename(p) for p in fs] == [f"{s}_{f}_{k:04d}.aselmdb" for k in range(len(fs))]
             order_ok = all(res[fs[k]][0][-1] < res[fs[k + 1]][0][0] for k in range(len(fs) - 1))
-            full_ok = all(len(res[p][0]) == 3 * per for p in fs[:-1])
+            full_ok = all(len(res[p][0]) == 3 * (per - SHORT.get(os.path.basename(p), 0)) for p in fs[:-1])
             print(f"{s}/{f}: {len(fs)} shards, {len(ms)//3} triplets; equals split file {same}; every row byte-identical to SciLM {bytes_ok}; "
                   f"names consecutive {names_ok}, shards in ms_id order {order_ok}, all but last full {full_ok}", flush=True)
             tot_ok &= same and bytes_ok and names_ok and order_ok and full_ok; seen.append(ms)
             for p in fs: obs_file.append(os.path.relpath(p, out)); obs_n.append(len(res[p][0])); obs_ms.append(res[p][0])
         seen = np.concatenate(seen); sad = seen[seen % 3 == 1]
-        kept = np.sort(np.array([m for m, r in zip(dms.tolist(), drep.tolist()) if m == r and ALL[sub_of[m]] == s], np.int64))
-        rem = set(m for m, r in zip(dms.tolist(), drep.tolist()) if m != r and ALL[sub_of[m]] == s)
+        kept = np.sort(np.array([m for m, r in zip(dms.tolist(), drep.tolist()) if m == r and m not in BROKEN and ALL[sub_of[m]] == s], np.int64))
+        rem = set(m for m, r in zip(dms.tolist(), drep.tolist()) if (m != r or m in BROKEN) and ALL[sub_of[m]] == s)
         u = len(np.unique(seen)) == len(seen); eqk = np.array_equal(np.sort(sad), kept); nrem = len(rem & set(sad.tolist()))
-        print(f"{s}: every ms_id once {u}; saddles == kept set of duplicates.parquet {eqk} ({len(kept)}); removed triplets present {nrem}", flush=True)
+        print(f"{s}: every ms_id once {u}; saddles == kept set of duplicates.parquet {eqk} ({len(kept)}); removed or broken triplets present {nrem}", flush=True)
         tot_ok &= u and eqk and nrem == 0
         # ASE-level spot check against the SciLM source
         from ase.db import connect

scripts/dedup/v2_write.py

@@ -2,7 +2,9 @@
 
 Every kept triplet (fold from <split_dir>/<subset>/{train,val,test}.parquet) is written to
     <out>/<subset>/<fold>/<subset>_<fold>_<NNNN>.aselmdb
-in ascending ms_id order (R, S, P rows of a triplet adjacent), at most <per_shard> triplets per file. Rows are NOT
+in ascending ms_id order (R, S, P rows of a triplet adjacent), at most <per_shard> triplets per file. The files are
+cut on the full split list, and then the BROKEN triplets are left out, so lemat_train_0213 and lemat_train_0479
+hold per_shard - 1 triplets and the other files do not change. Rows are NOT
 re-serialised: the zlib-compressed JSON value stored in the SciLM shard is copied unchanged under a new LMDB key
 ("1".."3n"; the id is not part of the stored value), then "nextid" = 3n+1 is written exactly as ase_db_backends does.
 Each file is written as <name>.tmp and renamed only after its transaction committed.
@@ -17,6 +19,9 @@ FOLDS = ["train", "val", "test"]
 src_root, idx_dir, split_dir, out = sys.argv[1:5]
 per = int(sys.argv[5]) if len(sys.argv) > 5 else 50000; nw = int(sys.argv[6]) if len(sys.argv) > 6 else 48
 SUBS = sys.argv[7].split(",") if len(sys.argv) > 7 else ["lemat", "mp20bat", "oc20", "oc22"]
+# saddle ms_ids of the 2 lemat triplets with broken forces (max |F| at the saddle 4.78e11 and 1.02e8 eV/A), found
+# after the split was drawn. They stay in the split lists, so that the file cuts do not move, and are not written.
+BROKEN = [35584423, 79800988]
 
 
 def load_index(s):
@@ -41,6 +46,7 @@ def plan():
             n = (len(sad) + per - 1) // per
             for k in range(n):
                 rows = pos[3 * k * per: 3 * (k + 1) * per]
+                rows = rows[~np.isin(ms[rows] // 3, np.array(BROKEN) // 3)]      # leave out the 3 rows of a BROKEN triplet
                 name = f"{s}/{f}/{s}_{f}_{k:04d}.aselmdb"
                 jobs.append((name, [shards[i] for i in range(len(shards))], fi[rows], key[rows], ms[rows]))
     return jobs