← All findings

F0004: mepd channels finds g-xTB transition states below the reference ones in Transition1x

Status: verified · Version 2, updated 2026-10-24 · Jan Estrada Pabon (ORCID) · 2026-10-24 · no DOI yet

Finding. Of 10,073 Transition1x reactions, 8,424 (83.6%) have a g-xTB transition state whose IRC connects the dataset's reactant and product. Searching them with mepd channels on g-xTB, 1,249 of them gave a verified route, every step of it reaching its minima by its own IRC, whose highest transition state lies more than 1 kcal/mol below that reference (14.8%; median 4.68 kcal/mol lower); for 431 (5.1%) no route was found.

Updated in version 2 (2026-10-24): corrected. Route steps must now reach their minima by their own IRC, and a reference IRC that stops short is retried with a stricter stopping point before a reaction is left out. 1,249 of the 8,424 reactions now in the set have a lower route (version 1: 1,232 of 8,271); 153 reactions rejoin the set, and in 20 the best route changed (11 now have none). Version 1's counts should not be used. How this Finding changed

Background

mepd is a tool for mapping reaction mechanisms. Given a reactant and a product, its search, mepd channels, looks for the transition state between them: the top of the energy hill the reaction has to climb. A lower hill means a faster reaction, so the lowest transition state connecting the two is the one that matters.

We test the search on reactions whose transition state is already known. Findings F0001 and F0002 did this for Reaction-QM; this Finding repeats both steps, with the same settings, on Transition1x, a dataset of about 10,000 reactions of small organic molecules whose transition states were found by nudged-elastic-band calculations with the density functional ωB97x. The search runs on g-xTB, a fast approximate quantum-chemistry method, so each known transition state is first carried over to g-xTB and kept only when it still leads to the dataset's reactant and product.

Approach

The benchmark set. We gave g-xTB each Transition1x transition state as a starting point and let it settle into the nearest g-xTB transition state, then followed the path downhill in both directions (the IRC) and minimized each end. A reaction is kept when the two ends are the dataset's reactant and product, and the IRC itself gets there: minimizing an IRC end must not turn it into another molecule. Where it did, the IRC was followed again, with a ten times stricter stopping point, and that IRC decides.¹

The search. For each kept reaction, mepd channels built several starting arrangements of the reactant and product and searched for paths between them on g-xTB.² Every transition state it reports was checked: optimized, then followed downhill to confirm it joins the requested reactant and product, either directly or through intermediates.³ Each step's IRC must reach its minima itself, by the same rule and with the same retry.⁴ We compared the best route's highest transition state with the known one, both on g-xTB; a route counts as lower when it is more than 1 kcal/mol below.⁵ All 8,424 reactions of the set were searched.⁶ Version 1 had neither the IRC retries nor the step check.⁷

Results

The benchmark set: 8,424 of 10,073 reactions (83.6%) are kept.

The stricter IRC was needed for 349 reactions; 153 of them are in the set.

The search.

The 10 single-step and 10 multistep routes furthest below the reference:

Compared with Reaction-QM (F0002), fewer searches find a lower route, and far fewer find none.¹¹ Counts are what one search budget found: a floor, not a ceiling. Higher levels of theory were not tested.

History

How this Finding has changed as more data came in, newest first.

Errors corrected in version 2:

• git commit 87d9f69 of mepd-workflows: routes were counted although a step's IRC reached its intermediate or end only after minimization turned the IRC end into another molecule
• git commit 87d9f69 of mepd-workflows: reactions whose reference IRC stopped short at fmax 0.1 eV/Å, so that minimizing an end changed its species, were left out without retrying a stricter IRC

Version 1 (2026-10-23) said: Outdated: corrected in version 2. Read version 1, with its data.

Of 10,073 Transition1x reactions, 8,271 (82.1%) have a g-xTB transition state whose IRC connects the dataset's reactant and product. Searching them with mepd channels on g-xTB, 1,232 of them gave a verified route whose highest transition state lies more than 1 kcal/mol below that reference (14.9%; median 4.69 kcal/mol lower); for 407 (4.9%) no route was found.

Details

1. Building the benchmark set

The F0001 protocol, unchanged. Each Transition1x ωB97x/6-31G(d) transition state was optimized to a first-order saddle at g-xTB 2.0.1 with Sella, starting from g-xTB's exact Hessian, until the largest atomic force was below 0.001 eV/Å (at most 1000 steps, then up to two more rounds of 1000), and accepted only with exactly one imaginary mode below −10 cm⁻¹. Sella's IRC (fmax 0.1 eV/Å, at most 1000 steps) then ran in both directions, and each end was minimized with the exact Hessian and checked by its frequencies, with up to three 0.1 Å pushes off a remaining saddle. When minimizing changed an IRC end into another molecule, the IRC was run again from the same transition state with fmax 0.01 eV/Å (at most 3000 steps per direction), and that IRC and its minimized ends decide the reaction; this was needed for 349 reactions (1 retry did not finish, and its first IRC stands). Two structures count as the same molecule when their bond graphs, perceived from geometry, and their stereochemistry agree. A reaction is kept when the minimized ends are the dataset's reactant and product (in either direction) and minimizing left each IRC end the same species. The set's reactant and product are those minimized IRC ends. Transition1x reactions are neutral, of C, H, N and O, and were computed as closed-shell singlets; the kept ones have 5 to 23 atoms. The kept reference transition states are high: median 80.73 kcal/mol above the reactant-side IRC end. 89 kept reactions have a soft transition state (imaginary mode above −200 cm⁻¹). Per reaction: data/screen.csv.

2. The search

mepd channels, with the F0002 settings unchanged. Each setting is explained in the mepd manual's page on channel searches (online; a copy is in this Finding's download as reproduce/mepd-manual-channels.html):

• 5 conformers per side (n_conformers): up to five RDKit conformers each of the reactant and of the product, chosen to differ in shape, each minimized on g-xTB. Every reactant conformer is paired with every product conformer.
• 5 path searches per mechanism (pairs_per_mechanism): the pairs are grouped by mechanism (which bonds break and which form, from SLAPMapper's atom mapping), and in each group only the five pairs whose two ends are closest in shape (endpoint-rmsd) get a path search.
• Direct paths only (direct_only): when a path turns out to pass through intermediates, only the pieces that start or end at the requested reactant or product are searched further.
• 30-minute search budget (search_budget): after 30 minutes no new path search starts and paths are no longer split; the transition-state optimizations and IRCs of what was found still run.
• 2-hour hard limit (hard time limit): the benchmark script stops a reaction's search after 2 hours, and the reaction then has no result.
• GSM with 20 nodes and at most 80 iterations (GSM settings) as the path method, one search per core.
• Checking intermediates (hessian_minimum_frequency_cutoff, hessian_minima_rescue_displacement): a path is split at an apparent intermediate only if it has no frequency below −20 cm⁻¹; one that fails is pushed 0.3 bohr along its lowest mode, each way, and minimized again.

The reactant and product are the minimized IRC ends of the re-converged reference transition state, so every search starts from the structures the reference is compared on. Screen and search ran with mepd git commit da31dcb.

3. What counts as a found route

Only routes mepd itself verified count. A single-step route is one transition state (exactly one imaginary frequency) whose IRC, with both ends minimized, reconnects the requested reactant and product species (bond graph and stereochemistry). A multistep route is a chain of such transition states through intermediates from reactant to product; its height is its highest transition state. Routes that lead to other species are not counted.

4. Each step must reach its minima by its own IRC

mepd channels files each step under the minima its IRC ends minimize to, without checking that minimizing kept each end the same molecule. We checked every step of every route found, lowest route first, with the rule of the benchmark set: when minimizing an IRC end changed it into another molecule, the step's IRC was run again from its transition state with fmax 0.01 eV/Å (at most 3000 steps). The step stands when both ends of that IRC keep their species on minimization and are the same two molecules as before. A route counts only when all its steps stand, and the best route is the lowest that counts. 178 step IRCs in 170 reactions were retried. The best route changed in 20 reactions; in 11 no route was left, and they count as no route found. routes_dropped and step_ircs_retried in data/search_outcomes.csv give the counts per reaction.

5. Comparing energies

Both barriers are measured from one floor per reaction, the lowest g-xTB energy of the reactant and its search conformers, so the amount lower is the reference transition state's energy minus that of the best route's highest one. Outcomes: lower (more than 1 kcal/mol below), about the same (within 1), only higher (every route more than 1 kcal/mol above). An IRC end of a route found can lie slightly below the floor (another arrangement of the reactant molecules); the barriers shown are then a little high, but the amounts lower do not depend on the floor.

6. Which reactions

Each of the 8,424 reactions of the benchmark set was searched once. Per reaction: data/search_outcomes.csv.

7. What version 1 got wrong

Version 1 counted routes with a step whose IRC reached its intermediate or end only after minimization turned the IRC end into another molecule, so the minimization, not the transition state, did part of the chemistry. It also left out of the benchmark set every reaction whose first IRC had that problem, without trying a stricter IRC. Version 1's counts (8,271 reactions in the set, 1,232 lower) should not be used; the searches of version 1 are reused unchanged, and the newly kept reactions were searched with the same settings.

8. When the IRC itself does not get there

Each minimized IRC end is compared with the raw IRC end it came from. In 15 reactions the minimized ends were the dataset's reactant and product, but minimizing had turned an IRC end into another molecule, so the g-xTB transition state is not that reaction's transition state. Mostly the IRC stopped far from a minimum: in 12 an end dropped more than 20 kcal/mol when minimized; 2 sit on soft saddles (imaginary mode above −200 cm⁻¹). These are not in the set. The rule is cautious: some may still be the same reaction. They are listed in data/screen.csv with status match and kept 0. The first IRC stops when the largest force falls below 0.1 eV/Å, which on a flat stretch of the surface can be far from a minimum; the stricter IRC brought 153 reactions back into the set (149 of them had matched the dataset's ends before, by minimization alone). irc_retried and loose_irc_status in data/screen.csv mark them. In the kept set, the median energy drop on minimizing an IRC end is 0.82 kcal/mol.

9. No route found

No transition state connecting the requested reactant and product was found within the budget: either no path search led to one, every transition state found led elsewhere, or every route found had a step whose IRC did not reach its minima by itself.⁴ It is not evidence that no such route exists. These reactions are listed in data/search_outcomes.csv with status no_route.

10. Searches stopped by an error

In each of these, every path search between the reactant and product failed (the path method, GSM, stopped with an error), so mepd had no result to compare and reports an error instead of "no route found". None ran out of memory or time. They are listed in data/search_outcomes.csv with status error; they are effectively reactions with no route.

11. Why no route was found

Each search builds conformers of the two ends, pairs them, and runs a path search pair by pair until its 30-minute budget is used up. One candidate pair is the reference IRC's own two ends, between which the reference transition state is known to lie. For the 420 reactions where no route was found at all (leaving out the 11 whose routes were all set aside), that pair:

In 12 of these reactions an IRC end was not among the conformers the search kept at all. 262 of the 420 searches used up the budget, and 341 found transition states that lead to other species. Unlike in Reaction-QM, where the pair of IRC ends was mostly not searched in time, here it was mostly searched and its path either split into steps the search does not follow or led to another transition state. Pairs are compared by geometry (sorted interatomic distances, 0.02 Å), since a search renumbers atoms when it maps the two ends. Per reaction: data/search_diagnostics.csv.

12. Where this holds

Level of theory. g-xTB 2.0.1 throughout: TS re-convergence, IRC and minimization (Sella through ASE and mepd's g-xTB engine), path search (GSM); gas phase. Reference TSs are Transition1x's ωB97x/6-31G(d) TSs re-converged at g-xTB.

Software.

• mepd: git commit da31dcb
• g-xTB: 2.0.1 (binary gxtb-xtb)
• GSM: patched molecularGSM (fork jandestrada/molecularGSM, branch mepd, git commit b21a100)

Chemical domain.

• Dataset: Transition1x (all 10,073 reactions screened; 8,424 in the set)
• Elements: H, C, N, O
• Total charges: 0
• Spin multiplicities: 1
• Atoms: 5–23
• Notes: Neutral closed-shell singlets with up to 7 heavy atoms; many high-barrier reactions.

Settings the result depends on.

• Screen: Sella TS optimization from the exact g-xTB Hessian, fmax 0.001 eV/Å, one imaginary mode below −10 cm⁻¹; Sella IRC fmax 0.1 eV/Å, retried at 0.01 eV/Å (3000 steps) when minimizing changed an end's species; ends minimized and frequency-checked; kept when both minimized ends are the dataset's and minimizing kept each IRC end's species
• Search: mepd channels: 5 RDKit conformers per side, direct paths only, 5 pairs per mechanism, RMSD cutoff 0.1, 1800 s search budget, 7200 s hard limit, Hessian minimum check (−20 cm⁻¹, 0.3 bohr rescue); GSM 20 nodes, 80 iterations
• Atom mapping: SLAPMapper, endpoint-RMSD metric
• Endpoints: the minimized IRC ends of the re-converged reference TS
• Route steps: a route counts only when every step's IRC ends keep their species on minimization (a failing step's IRC retried at fmax 0.01 eV/Å must then reach the same two species)
• Lower: best route's highest TS more than 1 kcal/mol below the reference TS, both from one shared floor

Tested on 8,424. Screen: all 10,073 Transition1x reactions. Search: every reaction of the set (8,424), each searched once.

Not tested.

• Whether the lower transition states are also lower at a higher level of theory.
• Reactions where the search found no route: a lower transition state may exist there too.
• Longer searches, more conformers or other path methods; the counts are what this budget found.

Known exceptions.

• An IRC end of a route found can lie slightly below the floor; barriers are then a little high, amounts lower are unaffected.
• Searches in which every path search fails stop with an error instead of reporting no route.
• Reactions whose reference IRC reached the dataset's endpoints only after minimization changed an end's species, even with the stricter IRC (15), are not in the set.
• The step check compares bond graphs and stereochemistry; a few steps fail it only because perception is undecided at a distorted IRC end (a bond at the length threshold, bond orders not assigned), and those routes are dropped.

Reproducibility: statistical. Rerunning the searches is not expected to find exactly the same routes: they depend on random conformers, timing and the code version. The screen is deterministic up to small numerical differences.

13. Data

data/screen.csv columns:

• reaction_id: T1X_ plus Transition1x's reaction name (rxnNNNN)
• status: from the deciding IRC: match (both minimized IRC ends are the dataset's reactant and product) | start_only | end_only (one of them) | mismatch (neither) | stereo_undetermined | degenerate_irc (both ends one well) | irc_end_not_minimized | ts_wrong_order (not exactly one imaginary mode) | ts_not_converged
• kept: 1 if in the set: status match and minimizing changed neither IRC end into another species
• irc_ends_kept_species: 1 if minimizing left both IRC ends the same species
• n_atoms: atoms
• n_heavy: heavy atoms
• ts_imaginary_cm: lowest frequency of the g-xTB TS, cm⁻¹ (negative = imaginary)
• start_end_drop_kcal: energy drop when the reactant-side IRC end was minimized, kcal/mol
• end_end_drop_kcal: the same for the product-side end, kcal/mol
• barrier_kcal: g-xTB TS above the minimized reactant-side IRC end, kcal/mol (match only)
• dataset_barrier_kcal: Transition1x's ωB97x/6-31G(d) TS energy above its reactant, kcal/mol (for reference only)
• seconds: screen wall time, s
• irc_retried: 1 if the first IRC (fmax 0.1 eV/Å) had an end that changed species on minimization and the IRC was retried at fmax 0.01 eV/Å, which decides the row; failed if the retry did not finish (the first IRC stands); 0 otherwise
• loose_irc_status: status from the first IRC, for rows where the IRC was retried

data/search_outcomes.csv columns:

• reaction_id: as in screen.csv
• n_atoms: atoms
• status: done (a route counts) | no_route (none found, or every route found had a step that failed the IRC check) | timeout (stopped at the 2-hour limit) | error (every path search failed, so the search had no result to compare)
• outcome: lower (> 1 kcal/mol below the reference) | matched (within 1) | higher (> 1 above); empty without a route
• best_kind: direct (one step) | multistep (its highest TS counts)
• ref_barrier_kcal: re-converged reference TS above the floor, kcal/mol
• best_barrier_kcal: best route's highest TS above the floor, kcal/mol
• lower_by_kcal: ref_barrier_kcal minus best_barrier_kcal (positive = found lower)
• n_direct: single-step routes found
• n_multistep: multistep routes found
• seconds: search wall time, s
• dataset_barrier_kcal: Transition1x's ωB97x barrier, kcal/mol (for reference only)
• screen_barrier_kcal: g-xTB barrier of the re-converged reference TS from its own IRC end, kcal/mol
• routes_dropped: routes found below the best one that counts, set aside because a step's IRC did not reach its minima by itself
• step_ircs_retried: route-step IRCs retried at fmax 0.01 eV/Å for this reaction

data/search_diagnostics.csv columns:

• reaction_id: as in screen.csv
• status: done (a route was found) | no_route
• readable: 1 if the search folder could be read
• n_pairs_possible: conformer pairs the search could form
• n_pairs_queued: pairs it chose to search
• irc_ends_in_pools: 1 if both IRC ends were among the conformers kept
• irc_pair_queued: 1 if the pair of IRC ends was chosen
• irc_pair_path_done: 1 if its path search finished
• irc_pair_path_split: 1 if that path went through intermediates
• budget_reached: 1 if the search used up its 30-minute budget
• legs_not_run: path legs through intermediates not followed (direct-only searches)
• n_offtarget: transition states found that lead to other species

check.py recomputes all 53 numbers in this report from these files and compares them with expected_numbers.json.

14. Reproducing it

Software. Python 3.12, mepd, g-xTB 2.0.1, patched molecularGSM, RDKit, Sella; one thread per task.

mepd version. Git commit da31dcb, the start of the commit hash that identifies this exact version of the mepd code (git checkout da31dcb).

Cost. Screen: about 93 core-hours for all 10,073, and about 3 for the stricter IRCs. Search: about 2,600 core-hours, median 17 minutes per reaction on one core; route-step check about 1 core-hour.

Download. F0004-v2.zip holds the data, the check script, the rerun scripts and the input structures of the search.

Check the numbers (a few seconds):

python check.py

Both reruns need uv and access to mepd (git commit da31dcb; mepd is not public yet, so uv fetches it over HTTPS with your GitHub credentials, e.g. after gh auth setup-git), and g-xTB 2.0.1 on PATH as gxtb-xtb.

Rerun the screen. It also needs Transition1x.h5 from Transition1x (version 4). The screen of all 10,073 reactions took about 93 core-hours (median 31 s per reaction on one core), and retrying the IRC where an end changed species (reirc, 349 reactions) about 3 more:

cd reproduce/rerun
export OMP_NUM_THREADS=1
uv run --no-config benchmark.py import-transition1x ws_screen PATH/Transition1x.h5
uv run --no-config benchmark.py screen ws_screen --timeout 3600 --jobs 8
uv run --no-config benchmark.py reirc ws_screen --timeout 1800 --jobs 8
python screen_table.py ws_screen rerun_screen.csv

Then compare rerun_screen.csv with data/screen.csv. --ids FILE (one reaction name per line, e.g. rxn0017) imports only those reactions.

Rerun the searches. These start from the structures in inputs.tar.xz, so the screen need not be rerun first. They also need the patched GSM from jandestrada/molecularGSM (branch mepd) on PATH as gsm. Each search takes up to 2 hours on one core (median 17 minutes); all 8,424 took about 2,600 core-hours. --jobs sets how many run at once. rescore then checks every step of every route found and retries the IRC of a step whose end changed species (about 1 core-hour in all).

cd reproduce/rerun
tar xJf ../../data/large/inputs.tar.xz        # -> ws/
export OMP_NUM_THREADS=1
uv run --no-config benchmark.py search ws --profile mepd_profile.toml --options search_options.toml \
  --timeout 7200 --jobs 8
uv run --no-config benchmark.py rescore ws --timeout 3600 --jobs 8
python outcomes.py ws rerun_search_outcomes.csv
python search_diagnostics.py ws rerun_search_outcomes.csv rerun_search_diagnostics.csv

Then compare the two tables with data/. A run can be stopped and started again: reactions already searched are skipped. To try a few reactions first, keep only their lines in ws/screen/results.jsonl before the search. The routes found may not match exactly: they depend on random conformers and timing. (benchmark.py can also send the work to the authors' cluster, --backend afh; that is not needed here.)

Reproductions.

• Passed on 2026-10-23, rerun by Jan Estrada Pabon. quick rerun exit 0
• Passed on 2026-10-24, rerun by Jan Estrada Pabon. quick rerun exit 0

15. Provenance

Captured: recorded by the run itself (provenance.json). Each screen and search stage records its mepd provenance (code version, settings, programs). The IRCs ran with mepd git commit da31dcb; the comparisons that decide the retried IRCs and the route-step check ran with mepd git commit 257dbb7, whose changes since da31dcb concern metal centres only (none in Transition1x).

16. Sources

Cited.

• Transition1x, Sci Data 2022: doi:10.1038/s41597-022-01870-w

Data this builds on.

• Transition1x data (figshare, version 4): doi:10.6084/m9.figshare.19614657.v4, license MIT

Software used.

• g-xTB: https://github.com/grimme-lab/g-xtb

Other Findings.

• Related F0001
• Related F0002