Eliah
And Elijah took his mantle, and wrapped it together, and smote the waters, and they were divided hither and thither, so that they two went over on dry ground. 2 Kings 2:8
A hydrogen atom does not always climb over the barrier of a chemical reaction. Often it passes through. The factor by which this changes the rate, the tunnelling coefficient κ, routinely enters rate calculations for hydrogen transfer, and its standard one-dimensional model is the Eckart barrier (Eckart 1930; Johnston and Heicklen 1962). The formula is exact and short, and many kinetics codes implement it. Implemented naively, it can fail in two regions, mostly without a warning. ELIAH computes κ correctly in both and is checked against 1197 values certified by ball arithmetic: the worst relative error is 4,5·10⁻¹⁴, thirteen significant digits.
Through the Wall
A wave packet runs into an Eckart barrier. Practically none of it has enough energy to reach the top of the barrier. Watch the far side.
Two Silent Failures
A common arrangement of the Eckart transmission probability (used, for example, in RMG-Py), with A and B from the energy and D from the barrier, is
- Cancellation. Below about 10⁻¹⁶ the difference 1 − (…) is exactly zero in double precision. At low temperature these deep-tunnelling energies carry much of the thermal average, so κ comes out too small.
- Small barriers. When 4√(V₁V₂) < hν, the quantity 2πd is imaginary and cosh 2πd must become cos 2π|d| (Johnston and Heicklen 1962; Brown 1981). Taking the cosh of the absolute value instead makes κ too small, by up to 98 % on the certified grid and more for smaller barriers, often below one where the true κ exceeds one.
ELIAH evaluates the same probability without the subtraction, in logarithms and with the correct branch for D,
where cosh D becomes cos |D| for small barriers. There the denominator is written as a sum of two non-negative terms,
so it cannot cancel either. ELIAH computes 1 − P directly where P is close to one and integrates the thermal average adaptively in t = √ε. Every result comes with ln κ, which stays finite where κ overflows, a quadrature error estimate, and a rigorous bound on the truncated tail.
The Library, Live
This is ELIAH itself: the Rust library compiled to WebAssembly, 48 kilobytes, computing on this page. Beside it runs the textbook arrangement, integrated with an equally accurate quadrature, so that only the arithmetic of P differs. Choose a barrier.
The Certified Map
The reference values were computed with Arb ball arithmetic: each is an interval that provably contains the exact κ. They span barriers α from 0,5 to 100 on both sides and u* = hν/kBT from 0,05 to 30. Every layer below is one u*; low temperature is to the right of the slider.
One Core, Every Language
The numerical core is written in Rust. Python needs no compiler: a pure-Python port gives bit-identical results on all certified points. The C interface serves C, Fortran and anything that can call C. A new header-only C++ layer turns its error codes into exceptions; it passes all 1197 certified points with GCC and with Clang.
pip3 install "git+https://github.com/sectio-aurea-q/eliah"
import eliah # V₁, V₂ in J/mol, ν‡ in cm⁻¹ (sign ignored), T in K print(eliah.kappa_si(160e3, 160e3, -1200.0, 200.0)) # 32639.069650545443 # barriers in k_BT, u = hν/k_BT print(eliah.kappa(4.0, 4.0, 2.0)) # 1.2222728996934293
// main.cpp: header-only C++17 layer over the C interface #include <cstdio> #include "eliah.hpp" int main() { const eliah::Kappa k = eliah::kappa_si(160e3, 160e3, -1200.0, 200.0); std::printf("%.10g (ln %.10g, %llu evaluations)\n", k.value, k.ln_value, static_cast<unsigned long long>(k.evals)); } // 32639.06965 (ln 10.39326531, 540 evaluations) // invalid input throws eliah::error, code() 1; no convergence, code() 2
Save it as main.cpp in a clone of the repository, then build and run (on macOS with DYLD_LIBRARY_PATH instead of LD_LIBRARY_PATH):
cargo build --release c++ -std=c++17 -Iinclude main.cpp -Ltarget/release -leliah -o main LD_LIBRARY_PATH=target/release ./main
/* main.c */ #include <stdio.h> #include "eliah.h" int main(void) { EliahResult r; int rc = eliah_kappa_si(160e3, 160e3, -1200.0, 200.0, &r); printf("rc %d, kappa %.10g, %d, %llu\n", rc, r.value, r.cos_branch, (unsigned long long)r.evals); } /* rc 0, kappa 32639.06965, 0, 540 */
Save it as main.c in a clone of the repository, then build and run (on macOS with DYLD_LIBRARY_PATH instead of LD_LIBRARY_PATH):
cargo build --release cc -Iinclude main.c -Ltarget/release -leliah -o main LD_LIBRARY_PATH=target/release ./main
In Cargo.toml:
[dependencies]
eliah = { git = "https://github.com/sectio-aurea-q/eliah" }fn main() -> Result<(), Box<dyn std::error::Error>> { let k = eliah::kappa_si(160e3, 160e3, -1200.0, 200.0)?; println!("{} (ln {}, quad err {:.1e})", k.value, k.ln_value, k.quad_err); Ok(()) } // 32639.069650545443 (ln 10.393265305318428, quad err 4.0e-10)
cargo install --git https://github.com/sectio-aurea-q/eliah eliah si 160 160 1200 200 eliah grid points.csv
The second line takes V₁ and V₂ in kJ/mol, ν‡ in cm⁻¹ and T in K, and prints {"kappa": 3.26390696505454434e4, "ln_kappa": 1.03932653053184278e1, …}; the third reads a CSV file with rows v1, v2, u in units of kBT.
Tested Against Certified Values
| Test | Points | Worst relative error |
|---|---|---|
| Certified Arb grid, α 0,5–100, u* 0,05–30 | 1197 / 1197 within 10⁻¹² | 4,5·10⁻¹⁴ |
| — of which in the small-barrier branch | 102 | 7,8·10⁻¹⁶ |
| Independent 50-digit reference, random, v up to 500 | 303 / 303 within 10⁻¹³ | 7,7·10⁻¹⁴ |
| Independent 50-digit reference, v 10⁻⁴–5·10⁴, u 0,0035–300 | 197 / 197 within 3·10⁻¹² | 2,2·10⁻¹² |
The independent reference starts from the Eckart potential itself, with the closed-form P(E) checked against a direct numerical solution of the Schrödinger equation (agreement 4·10⁻¹³). On the certified grid the largest error, 4,5·10⁻¹⁴, is at κ ≈ 10⁹⁸. Beyond the grid it grows with α, to 2,2·10⁻¹² for α₁ ≈ 10⁶, α₂ ≈ 4·10⁷ (κ ≈ 1). Both come from rounding in large arguments.
Any implementation that can be called from Python can run the same test:
# conformance/conformance.py in the repository # my_kappa(v1, v2, u): barriers in k_BT, u = hν/k_BT from conformance import run run(my_kappa, tol=1e-6)
Reported Upstream
The defects were reported to the maintainers of three open-source chemistry codes in October 2026; the TAMkin and pysisyphus reports already used this library, then called NETI, as the reference:
- RMG-Py, issue 3019: cancellation in 1 − ratio, and the missing cos branch for small barriers.
- TAMkin, issue 45: NaN for small barriers (missing cos branch) and for low imaginary frequencies (cosh overflow).
- pysisyphus, issue 341: NaN for realistic barriers, the wrong small-barrier branch, and Brown’s TUNL used outside its validated range.
What It Does Not Claim
ELIAH is the one-dimensional Eckart model and nothing more: not multidimensional tunnelling, not instanton theory, not small-curvature tunnelling. It is validated against certified and independent high-precision values; a single call is not itself a certified computation, and a ball-arithmetic mode for per-call enclosures is planned. The certified grid covers 0,5 ≤ α ≤ 100 and 0,05 ≤ u* ≤ 30. Beyond it the evidence is the independent 50-digit reference, and the error grows slowly, to about 2·10⁻¹² for α up to 4·10⁷.
Use and Cite
Source, tests and the certified grid: github.com/sectio-aurea-q/eliah, under the Apache-2.0 licence. Cite it as doi:10.5281/zenodo.23485066. ELIAH is the reference behind the boundary of the Hackfort Equation. It is named after the prophet Elijah, who crossed the Jordan on dry ground; until version 0.3.0 it was called NETI, and the renaming changed no number.