Capabilities and validation

Implemented ≠ validated. Working code is not a checked number.

Read this page before trusting any result. It lists every CLI method.kind (which references it accepts, which tasks it supports, the matching Python function, an example input) and the Python entry points. Each graded CLI method.kind gets a grade (three kinds are ungraded, and Python entry points are not graded individually), and the page shows how far each grade's numbers have been checked against an independent reference and where they are known to fail.

How to read it: find the capability in the matrix or the Python entry points. A matrix Grade cell links to the Anchors table when a row there holds the evidence; the Known limits section records the measured negatives. Every matrix cell comes from the CLI dispatch in crates/ferric-cli/src/lib.rs or the bindings in crates/ferric-python/src/lib.rs. The page is maintained by hand, so check those two files if a cell looks wrong. For keyword details see the input reference; for the example files see the examples index.

Grades

The grades are the ones ferric's CLI uses. Every CLI method.kind except laplace-sos-mp2 has a grade. A kind's grade is for the exact method; the local approximation of rimp2, drpa and linlccd (the [local] section) is graded separately in that row's Caveat. The CLI prints the Smoke and Spike grades as a [warning] line on stderr at run time; Proven kinds and the ungraded kind print nothing. The warning text is the EPISTEMIC_WARNINGS table in crates/ferric-cli/src/lib.rs, and the "Caveat" column of the matrix condenses it. The grades themselves are METHOD_KIND_GRADES in crates/ferric-core/src/certificate.rs, a copy of the Grade column below that a test keeps equal to it.

rhf, uhf, rohf and ksdft energy runs print a certificate block after the energy and write it to the JSON run log (run_end.extra.certificate; a certificate record for the open-shell runs); Python RhfResult, UhfResult and DftResult carry it as .certificate. It states the kind's grade, the build, the approximations in effect (RI-J / RI-K, LinK / COSX, the XC grid, a level shift, ECPs, embedding, solvation) and warnings: a Plateau exit, a non-Stable stability verdict, and an unchecked UHF/UKS stability. An unconverged SCF is capped to not graded.

Post-SCF kinds print a certificate block after their result: the MP2 family (rimp2 exact, local and open-shell, mp3, oo-rimp2, att-rimp2, mp2-v, scs-mp2, scs-mp2-2terfc, laplace-mp2, laplace-sos-mp2), rs-mp2-rpa, drpa, pdep-rpa, ccsd, ccd, ccsd(t), linlccd, wb97x-l-v, b2plyp, dsd-pbep86, tda, tddft, gw, bse-tda and tdhf-static-polarizability. Kinds that write a result record carry it as result.components.certificate; pdep-rpa, wb97x-l-v, b2plyp, dsd-pbep86, tda, tddft, gw, bse-tda and tdhf-static-polarizability write a certificate record. Python RiMp2Result, Mp3Result, OoRiMp2Result, AttenuatedMp2Result, ScsMp2Result, Mp2VResult, LaplaceMp2Result, SosMp2Result, RsMp2RpaResult, CcResult, PdepRpaResult, GwResult, UGwResult, BseResult, TdhfStaticPolarizabilityResult, DoubleHybridResult and TddftResult carry it as .certificate; the run_drpa and run_linlccd dicts carry a "certificate" key. The grade is the kind's row, capped at the grade of the SCF reference's certificate, whose approximations and warnings it repeats as scf <name> and scf reference: .... It records the auxiliary basis, frozen core, a non-Coulomb correlation operator and each method's settings (SCS scales, Laplace points, frequency quadrature, PDEP truncation, GW variant, double-hybrid scaling or λ and ω, the TDDFT response grid). Caps to not graded: an [local] amplitude threshold at finite eps, an unconverged orbital optimization (oo-rimp2), drCCD fixed point (drpa) or evGW eigenvalue loop. Warnings: GW and BSE-TDA runs at settings other than n_quad = 100, trunc_thresh = 0, unconverged quasiparticle roots, suspect quasiparticle energies, an unconverged PDEP eigensolver. Periodic runs (the CLI [cell] section and the Python Gamma-point and k-point results) carry a certificate with the grade not graded.

Symbols: ✓ = supported. — = not supported (the CLI refuses it with an error). FD = finite differences of the analytic gradient (6N gradient evaluations). The analytic Hessian covers closed-shell RHF and UHF of any multiplicity (both also with RI-J and/or RI-K, without an external potential; all with ECPs), and ROHF with exact J/K or RI and no external potential, with a basis up to f functions; rhf, uhf and rohf frequencies use it there by default.

CLI method.kind matrix

"Reference" is the SCF reference the CLI builds for that kind. Open-shell support is listed only where the dispatch code handles it (see Open shells below).

task = "optimize" is accepted only for rhf, ksdft, uhf, rohf, pdep-rpa and rimp2. task = "frequencies" is accepted only for rhf, ksdft, uhf and rohf. On an open-shell molecule both tasks are accepted only for uhf, rohf and ksdft (UHF/UKS, ROHF/ROKS). Both tasks refuse [dft] grid_prune, and [scf] k_builder = "cosx" except for rhf, ksdft, uhf and rohf (the overlap fit with a functional, and for rohf, is refused before the SCF); a COSX final pass is skipped for them. The RKS, UKS and ROKS optimizers and frequency drivers apply D3(BJ) and MBD@rsSCS (energy and exact gradient); an open-shell task = "energy" single point applies either. Any other combination exits with an error before the SCF runs.

Open shells in the CLI

• uhf and rohf read [molecule] multiplicity directly. With [dft] functional they run UKS and ROKS, for energies, optimizations and frequencies.
• ksdft with multiplicity > 1 runs UKS (the uhf route with the functional set). For ROKS use rohf with [dft] functional.
• rhf refuses multiplicity > 1 and points to uhf/rohf.
• rimp2 and oo-rimp2 run on the same plain UHF that kind = "uhf" runs, then take unrestricted RI-MP2 (UMP2, as PySCF mp.MP2(uhf)) and unrestricted OO-RI-MP2. [mp2] kappa is refused on an open shell. task = "energy" only: there is no unrestricted MP2 nuclear gradient.
• pdep-rpa, gw and mp2-v solve UHF with MOM after 5 iterations when multiplicity > 1, for task = "energy" only. For pdep-rpa and gw, setting [rpa] xc makes that reference UKS; gw with [gw] reference = "rohf" uses ROHF (ROKS with [rpa] xc) instead, semi-canonicalized per spin; U-G0W0 on a semi-canonicalized ROHF reference is in the Anchors, the ROKS reference is not compared. mp2-v does not read [rpa] xc and stays UHF.
• linlccd and wb97x-l-v refuse an open-shell molecule; their open-shell versions are library-only (ferric_cc::linlccd_u::u_linlccd, ferric_cc::double_hybrid::u_solve_wb97x_l_v).
• ccd, ccsd and ccsd(t) refuse an open-shell molecule, and no open-shell CCD, CCSD or CCSD(T) exists in the library either: every CC solver reads restricted orbitals.
• Every other kind refuses multiplicity > 1 with an error before any integral is computed.

Python entry points

These are Python functions without a method.kind of their own; some rows also have a CLI route through a TOML section or task, noted in the row. Scope is taken from the binding code and its docstrings. They are not graded individually.

Polarizable (Thole) embedding is Python and Rust only. IEF-PCM, UHF stability descent and terfc-attenuated MP2 are reachable from both: see [pcm], [scf] stability_descent and [mp2] att_operator in the Input reference.

Anchors

Where numbers are checked, they are checked against external references or exact limits, not against ferric's own earlier output. "Stated agreement" is the measured difference recorded in the repository; "test tolerance" is what the pinning test asserts, which is often looser. Proof links to the test file that asserts the row, and, where one exists, the script that generated its reference data; a row with nothing to link is not graded Proven. Proof files named validation_*.rs are #[ignore]d, so an ordinary cargo test skips them; they run in the weekly validation / validation-* CI jobs and on demand (cargo nextest run --run-ignored only -E 'binary(/^validation_/)').

A "—" means the repository states no number for that cell. It is left empty on purpose rather than filled with an estimate.

Benchmark sweeps (GW100 and others) are kept in the project's working notes and are not reproduced here. Quoting a benchmark statistic from memory rather than from the record is the kind of unchecked claim this page exists to prevent.

Mixed-precision GPU kernels

[precision] mode = "mixed" (deprecated alias: [gpu] precision = "mixed") is opt-in (the default is f64) and applies only to the kernels in mixed_kernels. A mixed result is not Proven: it is not compared with an independent code, and it is not an f64 result. It is graded as a measured error map: a deterministic bound derived from the operation count, and the errors measured against the same run's f64 CPU energy on the systems below. Whether that error is acceptable for a given use is not decided here.

rimp2-energy (shipped). B_ov is stored on the device as f32 (half the bytes of the f64 tensor); each block G_i = B_iᵀ·B_tail is formed by f32 panel products of width b = 64 (the shipped default) summed into an f64 accumulator; the pair arithmetic, denominators and all sums are f64. A finite B_ov element beyond the f32 range, or one above sqrt(f32::MAX / b) (an f32 panel sum of products could overflow), or an unavailable flush kernel, runs the f64 device path instead and is counted (mixed_fallback_f64); a NaN B_ov passes through to a NaN energy as on the CPU; a pool too small for the f32 tensor runs the CPU path unchanged.

The measured error against the f64 CPU energy of the same B_ov at b = 64 (E_corr is the f64 RI-MP2 correlation energy; every reference is an RI-JK RHF with loose thresholds, the same orbitals on both sides of each comparison). OS and SS are signed and partly cancel in the total, so all three are given:

Every component is inside its bound. The error splits into an f32-storage part (B_ov rounded to nearest through f32, recomputed in f64) and an accumulation part (the device minus that), each inside its own bound; at benzene / aug-cc-pVTZ the accumulation part (OS −9.4e-10) is the larger.

What the bound can and cannot catch. The energy bound is a worst case over rounding signs, three to six decades above the measured energy errors (at the worst single element the error reaches 7.1e-2 of its per-element bound at benzene / aug-cc-pVTZ and up to 1.2e-1 at dodecane, but those elements carry little of the energy). It catches gross defects, such as a wrong operand offset, a dropped panel or a dropped pair weight (1e-1 relative error). It does not catch a subtle degradation of the kernel: a plain SGEMM without the f64 flush, an f32 B_ov with an f64 GEMM, a truncating instead of round-to-nearest upload, or f32 accumulation across panels all stay inside it. They are pinned by other checks:

• The rounding mode is guaranteed by a bit-exact test: the device f32 B_ov equals as f32 (round to nearest, ties to even) element for element.
• The f64 flush across panels is guaranteed by a deterministic construction (panel sums +2²⁰, 2⁻⁹, −2²⁰ give exactly 2⁻⁹ on the device; summing the panels in f32 gives 0).
• The panel structure is checked by a measurement over every G block of benzene / aug-cc-pVTZ (18.3 million elements): the per-element RMS of err/S is 1.80e-8 for the device and 1.78e-8 for the host twin of the same algorithm (ratio 1.007), against 2.79× the twin for a plain SGEMM, 0.24× for an f32 B_ov with an f64 GEMM, 1.29× for a truncating upload and 1.30× for f32 accumulation across panels. The accepted device/twin ratio lies between 0.49 and 1.13 (the geometric midpoints to the nearest measured defect on each side). This measurement is supplementary and device and system dependent: its margin (about 13%) is of the size of the device/twin spread between systems (0.87 at water / cc-pVDZ, 1.007 at benzene / aug-cc-pVTZ), so it is not a guarantee on another device or build. Measured against the shipped b = 64, a panel width of 96, 128 or 256 reads 1.27, 1.51 or 2.39 (above the band); a width of 32 reads 0.70 (inside it: a more accurate kernel, a performance difference that is not pinned).

How the error depends on size. The per-element RMS of err/S falls with the auxiliary depth over the four cc-pVDZ systems: 4.9e-8, 2.5e-8, 2.1e-8, 1.8e-8 at naux 84, 364, 700, 1036; the fitted slope of ln RMS against ln naux is −0.40 ± 0.03 (2 degrees of freedom; one-sided 95% upper limit −0.32; the random-sign model predicts −0.5). This describes the shipped kernel; it is not a law and not a defect gate: naux is confounded with the molecule (without water the slope is −0.31), and a plain-SGEMM or truncating-upload emulation on the same blocks also falls with naux. No size dependence is claimed for the total energy error: its signed OS and SS parts scatter by two decades across systems through cancellation. Test files: crates/ferric-mp2/tests/rimp2_f32_storage_error_law.rs (no device; the name predates this wording) and crates/ferric-mp2/tests/gpu_rimp2_mixed.rs (device).

rimp2-energy, unrestricted (shipped, same kernel). The unrestricted (open-shell) Coulomb RI-MP2 energy keeps one f32 B_ov per spin on the device and forms every block of E_αα, E_ββ and E_αβ with the same f32 panel products of width b = 64 and f64 accumulation; the antisymmetrised same-spin K = g_ab − g_ba, the opposite-spin g², the denominators and all sums are f64. The refusals and the mixed_fallback_f64 counter are the closed-shell ones. The erfc and terfc unrestricted energies use the same kernel (next paragraph); every other caller of the unrestricted pair kernels (the erf operator, composite fitted operators, and direct calls of the pair kernels) runs the f64 device kernel.

The measured error against the f64 CPU energy of the same B_ov at b = 64 (cc-pVDZ / cc-pVDZ-RI, all electrons correlated; every reference is an RI-JK UHF with loose thresholds, the same orbitals on both sides):

Every block is inside its bound (largest error/bound 1.2e-2, O2 E_ββ). As in the closed-shell case the energy bound is blind to a subtle kernel degradation: a build that accumulates the whole contraction in f32 (one panel) stays inside it on both systems (O2 ΔE +9.2e-9 Eh). That degradation is caught by a deterministic construction through both the same-spin and the opposite-spin blocks (an element of exact value 1 + 2⁻³⁰ split over two panels: the device returns the f64 energy exactly; an f32 sum loses 2⁻²⁹ Eh, against an accepted error of 2⁻³⁰) and by the panel counter (⌈naux/b⌉ panels per block). Test files: crates/ferric-mp2/tests/gpu_u_rimp2_mixed.rs and crates/ferric-mp2/tests/gpu_u_rimp2_mixed_pin.rs (which callers may use the kernel).

rimp2-energy, erfc and terfc operators (shipped, same kernel). The RI-MP2 energy under the primitive erfc and terfc operators, closed-shell and unrestricted, runs the same kernel: plain and attenuated RI-MP2 (att-rimp2, dense and QQR-screened), SCS-MP2 with two terfc operators and the MP2 half of att-MP2+VV10. The per-element factor is the Coulomb one (a property of the arithmetic), but S_ab = Σ_P |B_P,ia||B_P,jb| and the underflow term are read from that operator's own dressed B_ov, whose metric is the attenuated (P|Q); a worse-conditioned attenuated metric would appear as larger |B| and larger S_ab / |g_ab| and is carried element by element. The bound assumes the reference is the f64 energy of the same f64 B_ov: the attenuated RI fitting error is common to both and is not part of it. The erf operator, composite fitted operators (terfc_fit), SR-MP2 inside RS-MP2+RPA and OO-MP2 (the energy kernel inside a larger algorithm whose sensitivity to this error was not analysed) and kappa-regularised runs stay on the f64 device kernel.

Measured at the repository defaults (erfc ω = 0.420 Å⁻¹, terfc r₀ = 1.05 Å), cc-pVDZ / cc-pVDZ-RI, all electrons correlated, against the f64 CPU energy of the same B_ov (RI-JK RHF / UHF references). At these parameters the dressed B_ov is as well scaled as the Coulomb one (water: max|B| 0.209 erfc, 0.211 terfc, 0.201 Coulomb; κ_E 1.306, 1.305, 1.304):

Every component (OS and SS, or αα, ββ and αβ) is inside its bound, and the f32-storage part of the error is above the f64 device gate on every one, so a caller that must stay f64 is told apart from a mixed one. These are small systems at moderate attenuation; a strongly attenuated or poorly conditioned metric is not measured here. Test files: crates/ferric-mp2/tests/gpu_rimp2_mixed_attenuated.rs (needs FERRIC_TERF_TABLE_DIR for the terfc rows) and crates/ferric-mp2/tests/gpu_u_rimp2_mixed_pin.rs.

xc-vxc (opt-in, not in the default mixed set: it runs only when mixed_kernels names it, under mode = "on"; on a GTX 1080 the device XC path, f64 or mixed, was slower than the CPU, so there is no reason to run it by default). It has run on hardware: on a GTX 1080 (Pascal, sm_61) gpu_xc_mixed.rs passes (device error in the twin's class, no f64 fallback), with 2 extra SCF iterations on benzene and |ΔE| ≤ 3.4e-13 Eh. The Kohn-Sham XC potential matrix of LDA and GGA functionals (closed- and open-shell; hybrids included, their exact exchange is untouched): each grid batch's V_b = A·Xᵀ is formed on the device from f32 A (weighted potential factors) and f32 X (basis-function values and gradients, stored once per grid as f32 next to the f64 copy) by f32 panel products of width b = 64 summed into an f64 accumulator. The density pass, the functional, E_xc and the V accumulation are f64. Meta-GGAs never use it (meta-GGA τ is on the never-f32 list; the device pass refuses mixed whenever τ is present, independently of the caller). A precision ladder decides per Fock build: a build is mixed only when the RMS change of some spin density since the previous build of the same SCF exceeds τ = 1e-5; the first build of every SCF (the ladder is reset when an SCF starts) and any one-shot V_xc are f64. At a converged exit whose last build was mixed, that build's V_xc is replaced by an f64 rebuild at the same density before the Fock matrix is diagonalised, so the Fock matrix and orbitals a converged SCF returns come from f64 builds whatever density_conv is and whichever exit accepted it (the energy needs no rebuild: E_xc comes from the f64 density pass and functional). A wave whose panel sums could leave the f32 range, or whose A does not round to f32, runs f64, and a missing flush kernel, an AO value beyond the f32 range or a pool too small for the f32 copies keep the grid f64 on the device; all are counted (mixed_fallback_f64).

Why the ladder. With every build mixed, the f32 panel sums act as rounding noise that changes with the density, and a tight SCF stalls on it: benzene / cc-pVDZ PBE took 77 instead of 12 iterations at density_conv = 1e-9 and did not converge in 200 at 1e-10. Rounding only the basis-function values (a fixed perturbation) costs nothing; rounding only A costs 2 to 6 iterations; the panel accumulation is the rest. τ = 1e-3, 1e-4 and 1e-5 kept 3-4, 4-5 and 6 of about 10 builds mixed for at most 3, 3 and 2 extra iterations.

The measured effect on converged SCF energies (host twin of the kernel, the same algorithm on OpenBLAS, against the f64 SCF of the same input; default SCF and grid settings; measured before the f64 rebuild at a converged exit existed, which by construction changes neither: it runs after the exit decision and E_xc never depends on the V_xc precision; not re-measured):

These are host-twin figures: the device kernel's own agreement with the twin (same error class, within a factor 10 on max|ΔV|) and a device SCF against the f64 host SCF are checked by crates/ferric-dft/tests/gpu_xc_mixed.rs, which needs a device; it passes on a GTX 1080 (sm_61). Test files: crates/ferric-dft/src/xc_batch.rs (element bound, no device), crates/ferric-scf/tests/xc_mixed_vxc_error_map.rs (this table, and the converged-exit Fock matrix against an independent f64 rebuild at a loose density_conv, RKS and UKS, no device).

dfk-occ (opt-in, not in the default mixed set: it runs only when mixed_kernels names it, under mode = "on"; on a GTX 1080 a mixed SCF saved about 0.7 s (4%) of the wall time against the f64 device DF-K at def2-TZVP, nothing measurable at def2-SVP, and was 3-6% slower with diffuse basis sets, so there is no reason to run it by default). The DF-K occupied path with the dressed B resident on the device as f32 and C_occ rounded to f32 on every build: each Y_P = C_occᵀ·B_P is a k-panelled f32 product of width b = 64 flushed into f64, and the SYRK and everything after it are f64. It runs behind the SCF precision ladder (crates/ferric-scf/src/jk_ladder.rs), shared with dfj-pack: a build is mixed only while the density moves by more than τ = 1e-5 and still contracts (one way: once it settles or stops contracting the SCF stays f64), a build the ladder keeps f64 runs the f64 device path on an f64 copy of B held beside the f32 one (rounded from it on the device, bit-identical to rounding on the host; when the pool cannot hold both copies, the f32 copy alone and the host f64 path), and a converged exit whose last build was mixed is refused and the iteration redone in f64. The energy is first-order in the K error, so that f64 exit, not a Fock-matrix swap, is what makes the returned energy and density f64 builds. A B element beyond the f32 range or a flush kernel that will not load runs the f64 device upload instead, counted (mixed_fallback_f64).

The measured effect on converged SCF energies: the device SCF with dfk-occ mixed against the f64 device SCF of the same input (RI-JK, def2-universal-jkfit, [gpu] mode = "on", default SCF settings, GTX 1080, the release CLI). "f64 exit |dE|" is the f64 run's energy change at its last iteration, the scale of its own termination noise:

The largest |ΔE| is 3.2e-12 Eh, against the 1.0e-3 Eh shipping bar, with no f64 fallback in any run. It is at or below the f64 run's own exit |dE| in every row but benzene / aug-cc-pVDZ (6.8e-13 against 2.8e-13, both at the 1e-12 scale of termination noise), so what it measures is the two runs' termination noise, not the kernel's error. The slope of ln |ΔE| against ln N is 2.29 ± 0.13 (standard error, 2 degrees of freedom) over the four alkanes with a nonzero |ΔE| and 1.27 ± 0.17 (8 degrees of freedom) over the ten such systems; it is the slope of that noise floor (the f64 exit |dE| grows with N too), not a growth law of the mixed error, which the ladder's f64 exit removes from the converged energy. With diffuse basis sets the mixed builds' own error holds the density change between builds at 5e-5 to 1e-4, above τ, while the DIIS error keeps falling. The ladder is therefore one way: the first build after a mixed one that finds the density settled (changed by at most τ) or not contracting (a change at least the previous build's) latches the SCF to f64 for good. Before the latch the ladder kept returning to mixed and DIIS stalled near τ: benzene / aug-cc-pVDZ took 44 to 103 iterations (the count depended on the last bits of the f64 K), and aug-cc-pVTZ 20, against 11 and 10 in f64; with it, 12 and 12.

Speed, n-dodecane RHF (RI-JK, the same card, 6 Rayon threads, two interleaved repeats each, whole-run wall time):

The def2-TZVP run spends 8.4-8.6 s in setup (the 3-index integrals and the V^-1/2 dressing of the DF-K tensor), the same in every arm, and 6.6 s (f64) against 6.0 s (mixed) building J and K over its 10 iterations. The first build, before there are occupied orbitals, factors the guess density's eigenvalues (314 of 528 kept) through the same occupied path. A mixed iteration took 0.47-0.48 s against 0.60 s, the iterations the ladder keeps f64 0.60-0.61 s (the f64 device path), and the first device build, which uploads the f64 B and rounds its f32 copy on the device, 1.02 s against 1.12 s. Holding both copies costs device memory: 4.58 GB of dressed B at def2-TZVP against 1.53 GB for the f32 copy alone and 3.05 GB in f64. On the benzene rows above the mixed SCF took 1.76-1.82 s against 1.66-1.75 s (aug-cc-pVDZ) and 4.9-5.0 s against 4.7-4.8 s (aug-cc-pVTZ).

The kernel itself (the derived K bound, the exact cross-panel flush and C_occ rounding pins, the multi-chunk build, the operand-class twin gate, every fallback) is checked by crates/ferric-scf/tests/gpu_dfk_mixed_kernel.rs, and the laddered SCF energy against a bar derived from the f64 floor by crates/ferric-scf/tests/gpu_jk_ladder.rs; both need a device and pass on a GTX 1080 (sm_61).

Known limits and negatives

• Analytic Hessians: closed-shell RHF, UHF and ROHF only (exact J/K, basis up to f functions, no solvent, no polarizable embedding; ECPs for RHF, UHF and ROHF (also with RI-J and/or RI-K) and external potentials for RHF and UHF but not ROHF; RI-J and/or RI-K for RHF, UHF and ROHF without an external potential). UHF states are not checked for internal stability or for being the lowest state: an unstable or excited UHF solution gets the Hessian of that solution. PySCF has no ROHF Hessian, so the ROHF reference is a finite difference of PySCF's analytic gradient. ROKS and every other method's frequencies take central finite differences of the analytic gradient.
• Local MP2: the integral-direct local MP2 (rimp2 with [local] integral_direct = true) has its correlation stage measured at about N^1.24 (erfc) and N^1.4 (Coulomb) on n-alkanes C20–C48 (6-31G / cc-pVDZ-RI, ε = 1e-4, frozen carbon cores, a calibrated pair gate; fitted to three points). That is one family of molecules in one basis: not shown to be linear, and not measured on 3-D or diffuse systems. Local MP2 without integral_direct still builds the global 3-index tensor and makes no scaling claim. See The MP2 family.
• DLPNO-MP2 PNO truncation is canonical and not compared like for like: ferric's pair-driven DLPNO-MP2 with PNO truncation builds PNOs per canonical occupied pair (dlpno_mp2_from_b_ov divides by a diagonal eps). A separate localized-occupied path (dlpno_mp2_localized_from_b_ov) does Boys-localized, Fock-coupled pair screening only, with no PNO or PAO truncation; ORCA localizes the occupieds and truncates PAO domains. The recoveries above are therefore reported side by side and never ranked. There is no DLPNO-CCSD or DLPNO-CCSD(T) energy driver, so ORCA's DLPNO-CCSD(T) figure is context only. The canonical pair screen is uninformative for n-butane to n-octane; with Boys-localized occupieds ferric's pair screen drops pairs (retention 0.585 frozen-core and 0.41 all-electron at C8, t_cut_pairs = 1e-4; the all-electron figure includes core pairs that the canonical screen also drops), measured only for these chains and below the locality onset. Library only.
• Exact dRPA by the Riccati solve is a small-system path: its ring-product plan holds no³·nv² numbers, no times the amplitudes themselves (C12 thrashed, then was killed for memory). The CLI and run_drpa refuse a run that cannot fit before the SCF; full-rank pdep-rpa gives the same energy at far lower memory.
• Laplace SOS-MP2, AO-sparse variant: the domain truncation is accurate, and the radius it needs grows far more slowly than the molecule (chemical accuracy at 3 to 5 Bohr on n-alkanes C2 to C12, radius/diameter falling from 0.52 to 0.17; a 71-atom drug molecule is within 0.05% at 4 Bohr, about 13% of its diameter). The algebra is still dense, so no speedup is claimed. The regression test sos_ao_sparse_truncation_radius_is_transferable_across_sizes pins the STO-3G butane/octane comparison (12 Bohr exact on both; octane worse at 3 Bohr). The C2-C12 sweep and the drug-molecule figure are measurements, not regression tests.
• TDHF/RPAx C6: ~63% low regardless of gap. Do not use it for dispersion. Its static α is implemented as specified (it matches an independent build of the same kernel, see anchors) but is not physically established: water/cc-pVDZ at PBE with a 0.36 Ha scissor gives 5.20 a.u. against DOSD 9.64 (−46%). A matching static α says nothing about the dynamic response that C6 needs.
• TDDFT / TDA: closed-shell references only. Functionals without an f_xc kernel (VV10, range-separated) are refused rather than run without it. B3LYP at aug-cc-pVDZ agrees with PySCF to 8.1e-4 eV on the default pruned grid and to 2.8e-6 eV on the reference's flat grid: the remainder is pruned-grid error. Meta-GGA excitations carry XC-grid error, so meta-GGA TDA/TDDFT defaults to a 150 × 434 grid: water r2SCAN TDA roots sit within 9.2e-5 eV (6-31G) and 5.5e-6 eV (aug-cc-pVDZ) of a flat 150 × 590 grid there, against 2.1e-3 eV on the 75 × 110 production grid (PBE: 4.4e-4 eV). SCAN is not grid-converged to 1e-4 eV on any grid tested: 3.6e-3 eV on the default, and flat 150 × 590 itself is 1.2e-3 eV from flat 200 × 590. See TDDFT.
• MP2 analytic polarizability (library only): one analytic path, mp2_polarizability_analytic → analytic_alpha_relaxed (see anchors); frozen_mp2_c6_molecular and the attenuation sweeps use it. It and the relaxed dipole (static_relaxed_density_ao) refuse a frozen core. The frozen-amplitude C6 takes its frequency shape from HF α(iω), not from an MP2 dynamic response.
• Periodic open-shell forces and stress refuse a non-stationary SCF state: a ROHF/ROKS orbital gradient or a k-point UKS spin commutator above 1e-5 Ha, a stored Fock more than 1e-8 Ha from the rebuilt one, or SCF k-points that are not the mesh's. Each tolerance and its provenance (measured, round-off or arbitrary) is in section 6 of crates/ferric-pbc/theory.md.
• COSX gains at high angular momentum and does not gain with system size. Measured on one thread at the flat (50,110) grid with the overlap fit:
  • Against LinK on n-alkanes at def2-SVP it is slower at every size measured: 1.59× (C20), 1.09× (C32) and 1.22× (C48), with no trend toward parity. At def2-TZVP on C20 it is faster (0.67×); that is the only triple-zeta size measured.
  • Against exact direct exchange on butane it is 3.7× slower at def2-TZVP (full SCF). At def2-QZVP its K build takes 90 s against about 400 s for the direct build's single J+K sweep, at a relative K error of 5.4e-5.
  • Its K build grows as N^1.29–N^1.32 between C20 and C48 at def2-SVP.
  • It applies to the Coulomb operator only: a range-separated functional takes its exchange from density-fitted short- and long-range fitters and ignores k_builder = "cosx", with a warning.
  • Its analytic gradient is exact for RHF, RKS, UHF, UKS, ROHF and ROKS with the overlap fit off, and for RHF and UHF with the default overlap fit, on flat and pruned (sgx) COSX grids. Fitted COSX with a KS functional, and fitted COSX for ROHF, are refused for gradient tasks, before the SCF runs.

Why the distinction is drawn so sharply

A quantum chemistry code can produce a plausible number in many ways that are wrong:

• a non-converged SCF returned as an ordinary result, because convergence is a flag rather than an error
• a method missing a physical term it does not mention (for example, TDDFT excitations computed without the f_xc kernel)
• a fallback model silently substituted for one atom in a molecule, changing a partitioning without changing the shape of the output
• a screening or truncation threshold that happens to be safe for the test system and not for yours

None of these look like failures, and every one of them has occurred in this codebase. The remedy is to grade each capability separately and say which ones are checked against ground truth.

Testing discipline

Some properties are pinned by tests rather than asserted in prose:

• Bit-identity across thread counts for reductions and permutations: results do not depend on RAYON_NUM_THREADS
• ERI 8-fold permutational symmetry: verified against the engine, not assumed, since the MP2 code relies on it to compute only ~1/8 of quartets
• Size-extensivity and rotational invariance of total energies
• Memory guards in both directions: a starved budget must be refused and an ample budget must still run, because an over-estimating guard is also a bug

New guards are mutation-tested: a defect is injected and the test confirmed to fail before the guard is trusted. This has caught guards that passed while proving nothing.

Related pages

• Input reference: every TOML key
• Examples: every shipped input file
• Python bindings