[challenge]: Exact diagonalization workbench in Rust for electronic structure method development

Released by

Guo CHEN, HKUST(GZ)

Contact email

guochen@hkust-gz.edu.cn

Method

Exact Diagonalization

Challenge issue

Challenge description

A full configuration interaction (FCI) code is the quantum chemist's exact diagonalization (ED): it solves the molecular electronic Schrödinger equation exactly in a finite basis (typically a Gaussian basis set). But an FCI code is more than a solver. Once we index a basis of determinants and apply second-quantized operators to FCI vectors, we can essentially implement any electronic structure method — exact or approximate, variational or otherwise — and this greatly accelerates method development because the code stays simple. Simple code can be trusted, and that is what the community uses it for: slow, transparent, determinant-based reference implementations are the standard instrument for double-checking fast, hand-optimized production codes (Smith 2018, Sun 2018).

The showcase for this challenge is arbitrary-order coupled cluster (CC). CC methods provide a hierarchy of approximations that is systematically improvable and size-extensive: truncating the cluster operator at successive excitation levels gives CC with single and double excitations (CCSD), then triples (CCSDT), then quadruples (CCSDTQ), and so on, which approach the exact solution within a basis set — but almost every production code hard-wires one truncation into thousands of lines of hand-derived equations. In 2000, three groups showed independently that CC at any excitation level n can be solved by reusing the determinant-based machinery of FCI (Hirata 2000, Kállay 2000, Olsen 2000). The primary reference, Hirata 2000, is itself the workbench thesis in action: one determinantal FCI code producing three method families — coupled cluster CC(n), configuration interaction CI(n), and many-body perturbation theory MBPT(n) through 20th order — with tables you will grade your own code against, digit by digit.

Your challenge: build this workbench in Rust, where nothing like it exists. The FCI engine comes first, arbitrary-order CC on top of it as the mandatory showcase, further methods as stretch goals — everything verified against oracles you construct yourselves and against the published tables. Research output: the Rust ecosystem's trusted reference implementation — the verification oracle that future optimized Rust electronic-structure codes get double-checked against, feeding the ecosystem effort of issues #114 and #115 together with a tenferro-rs gap list (substantial contributions may qualify for co-authorship on the planned software paper).

Background

Same method, different names. Exact diagonalization (ED) and full configuration interaction (FCI) are the same concept in different communities: represent the many-body Hamiltonian in a finite basis and solve the matrix eigenvalue problem — for the ground state, a few low-lying states, or in principle the full spectrum. Condensed-matter physics calls this ED and applies it to lattice models (Bonner 1964, Lin 1993, Weisse 2008); quantum chemistry calls it FCI. The FCI machinery is designed for molecular electronic Hamiltonians and is very efficient for that case. Molecules are not lattice models, so rather than forcing an analogy, this section introduces the FCI problem on its own terms and points you to the literature that the implementation actually needs.

The FCI problem. In second quantization the molecular electronic Hamiltonian reads

$$
\hat H = \sum_{pq} h_{pq} a_p^\dagger a_q + \frac{1}{2} \sum_{pqrs} (pq|rs) a_p^\dagger a_r^\dagger a_s a_q ,
$$

defined by one- and two-electron integrals $h_{pq}$ and $(pq|rs)$ over an orthonormal molecular-orbital basis. Note that $(pq|rs)$ follows the Mulliken index ordering used throughout quantum chemistry, not the Dirac ordering $\langle pq|rs\rangle$ common in many-body physics — look up the two conventions before writing any code that touches the integrals. You never compute these integrals yourself: they arrive in a standard text format called FCIDUMP, produced by an electronic-structure package such as PySCF (Sun 2018). The basis of the eigenvalue problem is the set of Slater determinants, which factorizes into pairs of alpha/beta occupation bit-strings (Handy 1980, Olsen 1988). Because every orbital pair interacts, the Hamiltonian couples each determinant to all its single and double excitations; efficient implementations therefore never store $\hat H$, but apply it directly to a trial vector — the direct-CI sigma vector, $\sigma = \mathbf{H}\mathbf{C}$ — using precomputed lists of single excitations between strings together with their sign factors, the coupling coefficients (Knowles 1984, Knowles 1989). Sherrill 1999 is the recommended entry-point review. And this machinery is anything but historical: it beats at the heart of actively developed packages such as Quantum Package (Garniron 2019), and its scaling frontier moved from a billion determinants in 1990 (Olsen 1990) to a quadrillion in 2025 (Shayit 2025).

Iterative eigensolvers. Lanczos and Davidson, both Krylov-subspace methods, extract one or several extremal eigenpairs from repeated sigma-vector constructions alone. Quantum chemists favor the Davidson method (Davidson 1975; see Crouzeix 1994 for a numerical-analysis treatment) because the diagonally dominant Hamiltonian makes its preconditioner effective. The mandatory target here is the ground state; extending to several states with the block Davidson variant — known in quantum chemistry as the Davidson–Liu simultaneous expansion method — is natural.

Coupled cluster. FCI cost grows exponentially with system size, so the workhorse methods approximate it. Instead of the linear expansion $|\Psi\rangle = \hat C |\mathrm{HF}\rangle$ of CI, CC writes

$$
|\Psi\rangle = e^{\hat T} |\mathrm{HF}\rangle, \qquad \hat T = \hat T_1 + \hat T_2 + \cdots + \hat T_n ,
$$

where $|\mathrm{HF}\rangle$ is the Hartree–Fock reference determinant and $\hat T_k$ is the k-fold excitation operator: it moves k electrons from orbitals occupied in $|\mathrm{HF}\rangle$ into unoccupied ones, with one unknown amplitude per choice — for a single electron, $\hat T_1 = \sum_{i}^{\mathrm{occ}} \sum_{a}^{\mathrm{virt}} t_i^a a_a^\dagger a_i$, and the pattern continues (explicit forms through $\hat T_3$: Eqs. (2)-(5) of Hirata 2000; theory: Crawford 2000, Bartlett 1995, Bartlett 2007). The CC(n) series reaches FCI at n = N, the number of electrons, and converges quickly when a single determinant dominates the wave function, as for water at equilibrium; strong correlation (stretched bonds, near-degeneracies) slows it down — the regime the optional hard mode in the Hints probes. A notation warning: CC(n) here means CC with the cluster operator truncated at excitation level n, so CC(2) is CCSD — not to be confused with the approximate models named CC2 and CC3 in the literature (Christiansen 1995), which are different methods. The catch: the amplitude equations are nonlinear, and deriving them by hand at each excitation level is what this challenge eliminates.

Setup

The primary test system is the water molecule in the settings of Hirata 2000: the 6-31G basis, oxygen 1s core frozen, at the equilibrium geometry (r_OH = 0.967 Å, HOH angle 107.6°). Its Tables 1–3 grade your code digit by digit — and they cover CI(n) and MBPT(n) as well as CC(n), so the same data grades the stretch methods. The extended targets are water in the DZ and DZP basis sets of Bauschlicher 1986, graded by Tables II and III of Kállay 2001.

The single Hamiltonian primitive is the sigma-vector construction $\sigma = \mathbf{H}\mathbf{C}$ on full-CI-length vectors. CC is then solved in determinant-based form, directly in the basis of Slater determinants — the route of Hirata 2000 (independently Kállay 2000 and Olsen 2000). The recipe: keep the cluster amplitudes for all excitation levels up to n, apply $\hat T$ to full-CI-length vectors with the same string machinery, build $e^{\hat T}|\mathrm{HF}\rangle$ by the Taylor series (which converges numerically thanks to the $1/k!$ factors, and eventually terminates exactly, since each power of $\hat T$ raises the excitation level and excitations beyond the electron count vanish), and solve the projected equations

$$
E = \langle \mathrm{HF} | \hat H e^{\hat T} | \mathrm{HF} \rangle, \qquad \langle \mu | (\hat H - E) e^{\hat T} | \mathrm{HF} \rangle = 0 ,
$$

projecting on all determinants $|\mu\rangle$ up to excitation level n, by Jacobi-type amplitude updates (divide each residual by its orbital-energy denominator), accelerated by DIIS extrapolation (direct inversion in the iterative subspace, Pulay 1980). Every piece of this recipe is written out in Sec. 2 of Hirata 2000 — the projected equations are its Eqs. (6)-(9), the residual vector Eqs. (12)-(14), the denominator update Eq. (16), and Fig. 1 gives loop-by-loop pseudocode for building $e^{\hat T}|\mathrm{HF}\rangle$ on alpha/beta strings — so implement from there. This formulation costs exponential memory like FCI — that is fine for water — but it is correct at every excitation level n, requires no diagrams, and reuses the FCI code path. (Removing the FCI-type overhead, as Kállay 2001 did with strings and diagram factorization, is what production codes do; it is far beyond a hackathon and not part of this challenge.)

Tasks

Levels 0-3 form a dependency ladder: each one builds on, and verifies, the one before; Level 4 stands apart and can start any time after Level 0. How you divide the work is up to you.

Level 0 — Build your own oracle. Use LLM agents to drive PySCF: run a restricted Hartree–Fock calculation, have the library transform the integrals to the molecular-orbital basis, and export them — pyscf.tools.fcidump.from_scf(mf, "FCIDUMP") does the whole chain in one call (atomic-orbital (AO) integrals from libcint (Sun 2015), the AO-to-MO transformation via pyscf.ao2mo, and the FCIDUMP write-out). Generate FCIDUMP files for the suggested systems (H2, H4, then water in STO-3G and 6-31G) together with reference energies (Hartree–Fock, FCI via pyscf.fci, CCSD via pyscf.cc) stored as JSON, plus a small script that compares your Rust output against them. In Rust: parse FCIDUMP, enumerate alpha/beta strings, build the Hamiltonian matrix explicitly for the tiny systems, diagonalize it densely, and match your reference numbers. Designing the verification harness is part of the challenge, not scaffolding.

Level 1 — String-based direct FCI (mandatory). Implement precomputed single-excitation lists between strings with their coupling coefficients, the Olsen/Knowles–Handy sigma-vector construction, and a Davidson eigensolver. Target: water/6-31G, frozen core. Verify against your Level-0 PySCF oracle and against the FCI energy printed in the caption of Table 2 of Hirata 2000. Extended target: water/DZ, all electrons.

Level 2 — Determinant-based arbitrary-order CC (mandatory showcase). Implement the determinant-based CC solver described in Setup (Hirata 2000), for arbitrary n. Verify CC(2) — which is CCSD, not the approximate CC2 model (see Background) — against PySCF, then the whole CC(n) series against Table 2 of Hirata 2000 (equilibrium column). Extended targets: Table II of Kállay 2001 (water/DZ, all electrons) and — if your machine allows — Table III (water/DZP, oxygen 1s frozen).

Level 3 — More methods from the same workbench (stretch). The point of the machinery you now own: new methods can be prototyped rapidly, without first deriving and hand-coding tedious equations. Three directions, roughly in order of effort:

• CI(n). Truncated CI is your Davidson solver restricted to excitation level n (and linearized CC, a small variation on your CC solver, sits in the Kállay tables next to it). Graded by the same Table 2 of Hirata 2000 and Tables II/III of Kállay 2001.
• MBPT(n). High-order many-body (Møller–Plesset) perturbation theory falls out of the same machinery by recursion, and Hirata 2000 tabulates it through 20th order. Historic FCI-code territory: this is how the convergence and divergence of the MP series was first mapped.
• Unitary CC(n). Replace $e^{\hat T}$ by $e^{\hat T - \hat T^\dagger}$ and minimize the energy expectation value over the amplitudes with a numerical optimizer (the projected-equation trick no longer applies). This ansatz is the backbone of variational quantum eigensolvers in quantum computing, and exact classical values for small molecules are reference data the field actually needs.

Level 4 — Own your integrals (stretch, independent of Levels 2-3). So far every calculation starts from a PySCF-generated FCIDUMP, so Python remains in the loop. Cut the cord: call the libcint integral engine (Sun 2015) directly from Rust — bindings already exist (the libcint crate, grown out of the rest_libcint wrappers of the REST electronic-structure toolkit (Li 2025)) — then implement restricted Hartree–Fock (assemble overlap, kinetic, nuclear-attraction, and two-electron integrals; solve the generalized eigenvalue problem $\mathbf{F}\mathbf{C} = \mathbf{S}\mathbf{C}\epsilon$ iteratively, reusing your DIIS) and the four-index AO-to-MO transformation. Your workbench is then a self-contained Rust electronic-structure stack, with PySCF demoted to a cross-check. Verification is built in: your own molecular-orbital integrals must reproduce your FCIDUMP-based energies to near machine precision.

Compute reality check

• Water/6-31G, frozen core (primary): 245,025 determinants; an FCI vector is about 2 MB. Every mandatory calculation runs in seconds on a laptop.
• Water/DZ, all electrons (extended): about 10^6 determinants in the relevant symmetry block (about 4 x 10^6 ignoring spatial symmetry); a vector is a few MB. The Davidson solve and the Taylor-series CC iterations need only a handful of such vectors — Kállay 2001 produced all of its Table II on an 800 MHz Athlon.
• Water/DZP, frozen core (extended): about 2.8 x 10^7 determinants; a vector is a few hundred MB. Feasible on a laptop with care, comfortable on a workstation.
• Published anchors: the FCI energies are -76.121174 hartree (6-31G, frozen core, equilibrium; Hirata 2000, Table 2 caption), -76.156699 hartree (DZ, all electrons) and -76.256624 hartree (DZP, frozen core; both Kállay 2001). If your energies do not converge to these, either your code or your reproduction of the settings is wrong — both are worth finding out.
• The Level 3 methods reuse the same vectors and the same operator machinery; no new memory scale appears.

Hints and pitfalls

• Matching published tables requires reproducing their exact settings. For the primary target they are in Hirata 2000 itself: 6-31G, frozen oxygen 1s, r_OH = 0.967 Å, HOH angle 107.6°, restricted Hartree–Fock canonical orbitals. For the extended targets, the geometry and DZ/DZP bases come from Bauschlicher 1986 (all-electron in DZ, frozen core in DZP). Digging such details out of papers (agents are good at this) is an intentional reproducibility exercise.
• Indexing the determinant basis: identify each alpha/beta string by its occupied-orbital list in ascending order (equivalently, its occupation bit-string), and map strings to consecutive integers by lexical ordering. The forward transform (string to index) is the addressing array of Knowles 1984, Eqs. (11) and (12) — lexical without gaps, with a worked example in the paper — and is also available as a standalone algorithm (Walter 1963); the reverse transform (index to string) is combination unranking, spelled out as Buckles 1977. A determinant's index is then just the pair (alpha-string address, beta-string address) into a rectangular array.
• Fermion sign bookkeeping in the string excitation lists is where most bugs live. Test H2 and H4 exhaustively — every matrix element against the dense build — before touching water.
• FCIDUMP files store $(pq|rs)$ in Mulliken ordering with 8-fold permutation symmetry, 1-based orbital indices, and spatial-orbital (not spin-orbital) integrals; read the PySCF tools.fcidump source rather than guessing.
• The Taylor series for $e^{\hat T}|\mathrm{HF}\rangle$ can be truncated early: the $1/k!$ factors shrink the terms fast, so stop summing once the norm of the next term is below your convergence threshold.
• All mandatory targets are at equilibrium geometry, where plain amplitude iterations with DIIS converge without drama. Hirata 2000 declares convergence when the norm of the residual vector drops below 10^-6, which settles the energy to about 10^-7 hartree — tight enough to match the tables digit by digit. Hirata 2000 also tabulates stretched geometries (1.5 and 2.0 times the equilibrium bond length) — treat those as an optional hard mode: convergence degrades, and the MBPT series famously diverges there.
• The alternative route to general-order CC is symbolic: derive the equations automatically and generate code, as in the Tensor Contraction Engine (Hirata 2003). Knowing it exists tells you what the determinant-based approach buys: no code generation, one compiled kernel for every excitation level and — as Level 3 shows — for many methods.

Tools

• Rust toolchain (cargo). The engine must be Rust; Python is allowed only for oracle generation and verification scripts.
• tenferro-rs for dense tensor contractions where they fit (see issue #115) — in this workload that is chiefly the integral-contraction block of the Olsen-style sigma-vector algorithm, a dense matrix-matrix multiplication (GEMM). The dominant kernels of string-based FCI are different in kind: indexed gather/scatter-add over rows with sign flips, driven by integer excitation tables, plus element-wise divides (Davidson preconditioner, orbital-energy denominators) and in-place axpy/dot. Where these do not map onto tenferro-rs, use faer or hand-rolled kernels plus BLAS bindings — and record each such place in your gap list (scatter-add and indexed accumulation, mutable views and slicing, element-wise division, in-place BLAS-1 ops). Probing tenferro-rs from an angle tensor-network workloads never reach is part of this challenge's value.
• PySCF (install via uv) as the molecular-orbital integral provider — Hartree–Fock, AO-to-MO transformation via its built-in libcint integral engine (Sun 2015), FCIDUMP export — and for reference FCI/CCSD energies (Sun 2018); the Level 4 stretch replaces this dependency with direct libcint calls from Rust. Psi4NumPy for readable NumPy reference implementations of the same algorithms (Smith 2018).
• For Level 4: libcint itself, the C library for Gaussian-orbital integrals (Sun 2015), and its Rust bindings — the libcint crate (docs, with a PySCF-mol.intor-style API and build-from-source support), derived from the rest_libcint wrappers of REST (Li 2025).
• For unitary CC: any numerical optimizer (conjugate gradients or L-BFGS; argmin and pounce are Rust options). Numerical gradients are acceptable.
• Your LLM agent harness, for oracle construction, literature detective work, and porting help.

Deliverables

1. A Rust implementation through Level 2, with the self-built verification harness and oracle data (FCIDUMP files, reference JSON, verify script) committed alongside it.
2. Accuracy tables: your FCI and CC(n) energies against the Level-0 oracle and against Table 2 of Hirata 2000, plus the Kállay 2001 extended targets and any Level 3 series (CI(n), MBPT(n), unitary CC) you attempted.
3. A tenferro-rs gap list: missing operations, numerical issues, performance gaps, API friction (feeds issues #114/#115).
4. A PR into tracks/<track>/solutions/<team>/ with a README explaining your design decisions, plus the reproduction prompt required by the school's submission rules.

References

• Hirata 2000 — S. Hirata, R. J. Bartlett, High-order coupled-cluster calculations through connected octuple excitations, Chem. Phys. Lett. 321, 216 (2000). 10.1016/S0009-2614(00)00387-0. The primary reference and grading data (Tables 1–3): CC(n), CI(n), and MBPT(n) from one determinantal FCI code — the workbench thesis of this challenge in action. Sec. 2 contains every working equation and the pseudocode for Level 2.
• Kállay 2000 — M. Kállay, P. R. Surján, Computing coupled-cluster wave functions with arbitrary excitations, J. Chem. Phys. 113, 1359 (2000). 10.1063/1.481925. Independent determinant-based general-order CC, via a different iteration scheme.
• Olsen 2000 — J. Olsen, The initial implementation and applications of a general active space coupled cluster method, J. Chem. Phys. 113, 7140 (2000). 10.1063/1.1290005. Independent determinant-based general-order CC, generalized to arbitrary active spaces.
• Kállay 2001 — M. Kállay, P. R. Surján, Higher excitations in coupled-cluster theory, J. Chem. Phys. 115, 2945 (2001). 10.1063/1.1383290. Cited for its Tables II and III, the extended grading data; its efficient string-based algorithm (the core of the MRCC program) is beyond this challenge.
• Knowles 1984 — P. J. Knowles, N. C. Handy, A new determinant-based full configuration interaction method, Chem. Phys. Lett. 111, 315 (1984). 10.1016/0009-2614(84)85513-X. The string-based sigma-vector algorithm; Eqs. (11)-(12) define the lexical string addressing (string-to-index direction).
• Olsen 1988 — J. Olsen, B. O. Roos, P. Jørgensen, H. J. Aa. Jensen, Determinant based configuration interaction algorithms for complete and restricted configuration interaction spaces, J. Chem. Phys. 89, 2185 (1988). 10.1063/1.455063. Alpha/beta string factorization; the loop structure you will implement.
• Handy 1980 — N. C. Handy, Multi-root configuration interaction calculations, Chem. Phys. Lett. 74, 280 (1980). 10.1016/0009-2614(80)85158-X. Origin of the alpha/beta string idea.
• Knowles 1989 — P. J. Knowles, N. C. Handy, A determinant based full configuration interaction program, Comput. Phys. Commun. 54, 75 (1989). 10.1016/0010-4655(89)90033-7. A complete reference implementation, described in detail.
• Walter 1963 — H. F. Walter, Algorithm 151: location of a vector in a lexicographically ordered list, Commun. ACM 6, 68 (1963). 10.1145/366246.366260. Combination ranking — the string-to-index direction of the basis addressing.
• Buckles 1977 — B. P. Buckles, M. Lybanon, Algorithm 515: generation of a vector from the lexicographical index, ACM Trans. Math. Softw. 3, 180 (1977). 10.1145/355732.355739. Combination unranking — the index-to-string direction of the basis addressing.
• Davidson 1975 — E. R. Davidson, The iterative calculation of a few of the lowest eigenvalues and corresponding eigenvectors of large real-symmetric matrices, J. Comput. Phys. 17, 87 (1975). 10.1016/0021-9991(75)90065-0. The eigensolver.
• Crouzeix 1994 — M. Crouzeix, B. Philippe, M. Sadkane, The Davidson method, SIAM J. Sci. Comput. 15, 62 (1994). 10.1137/0915004. The Davidson method from the numerical-analysis side: convergence theory and its relation to Lanczos.
• Pulay 1980 — P. Pulay, Convergence acceleration of iterative sequences. The case of SCF iteration, Chem. Phys. Lett. 73, 393 (1980). 10.1016/0009-2614(80)80396-4. The original DIIS paper — the convergence accelerator for the CC amplitude iterations (and Hirata 2000's own citation for it).
• Sherrill 1999 — C. D. Sherrill, H. F. Schaefer, The configuration interaction method: advances in highly correlated approaches, Adv. Quantum Chem. 34, 143 (1999). 10.1016/S0065-3276(08)60532-8. Entry-point review of CI/FCI.
• Olsen 1990 — J. Olsen, P. Jørgensen, J. Simons, Passing the one-billion limit in full configuration-interaction (FCI) calculations, Chem. Phys. Lett. 169, 463 (1990). 10.1016/0009-2614(90)85633-N. The billion-determinant milestone of 1990.
• Garniron 2019 — Y. Garniron et al., Quantum Package 2.0: an open-source determinant-driven suite of programs, J. Chem. Theory Comput. 15, 3591 (2019). 10.1021/acs.jctc.9b00176. A modern, actively developed determinant-driven package built on the same machinery.
• Shayit 2025 — A. Shayit et al., Numerically exact configuration interaction at quadrillion-determinant scale, Nat. Commun. 16, 11016 (2025). 10.1038/s41467-025-65967-7. The current scaling frontier of exact CI.
• Bonner 1964 — J. C. Bonner, M. E. Fisher, Linear magnetic chains with anisotropic coupling, Phys. Rev. 135, A640 (1964). 10.1103/PhysRev.135.A640. The founding small-cluster ED paper in condensed matter.
• Lin 1993 — H. Q. Lin, J. E. Gubernatis, Exact diagonalization methods for quantum systems, Comput. Phys. 7, 400 (1993). 10.1063/1.4823192. The ED side: bit-string basis coding for lattice models.
• Weisse 2008 — A. Weisse, H. Fehske, Exact diagonalization techniques, Lect. Notes Phys. 739, 529 (2008). 10.1007/978-3-540-74686-7_18. ED lecture notes from the condensed-matter community.
• Christiansen 1995 — O. Christiansen, H. Koch, P. Jørgensen, The second-order approximate coupled cluster singles and doubles model CC2, Chem. Phys. Lett. 243, 409 (1995). 10.1016/0009-2614(95)00841-Q. The method named CC2 — cited only to disambiguate it from CC(2) = CCSD in this challenge's notation.
• Crawford 2000 — T. D. Crawford, H. F. Schaefer, An introduction to coupled cluster theory for computational chemists, Rev. Comput. Chem. 14, 33 (2000). 10.1002/9780470125915.ch2. The standard CC pedagogical introduction.
• Bartlett 1995 — R. J. Bartlett, Coupled-cluster theory: an overview of recent developments, in Modern Electronic Structure Theory Part II, Adv. Ser. Phys. Chem. 2, 1047 (1995). 10.1142/9789812832115_0005. CC review.
• Bartlett 2007 — R. J. Bartlett, M. Musiał, Coupled-cluster theory in quantum chemistry, Rev. Mod. Phys. 79, 291 (2007). 10.1103/RevModPhys.79.291. The canonical modern CC review, written for a physics readership.
• Bauschlicher 1986 — C. W. Bauschlicher, P. R. Taylor, Benchmark full configuration-interaction calculations on H2O, F, and F-, J. Chem. Phys. 85, 2779 (1986). 10.1063/1.451034. Source of the geometry and DZ/DZP basis sets of the extended targets.
• Sun 2015 — Q. Sun, Libcint: an efficient general integral library for Gaussian basis functions, J. Comput. Chem. 36, 1664 (2015). 10.1002/jcc.23981. The integral engine underneath PySCF, and the Level 4 target for direct Rust calls.
• Li 2025 — Z. Li et al., REST: embracing the Rust programming language for modern electronic structure theory, Chin. J. Chem. Phys. 38, 788 (2025). 10.1063/1674-0068/cjcp2510156. A Rust-native electronic-structure program (SCF and beyond) whose rest_libcint wrappers seeded the libcint crate used in Level 4.
• Sun 2018 — Q. Sun et al., PySCF: the Python-based simulations of chemistry framework, WIREs Comput. Mol. Sci. 8, e1340 (2018). 10.1002/wcms.1340. Oracle generation; its deterministic FCI module is the community's everyday cross-checking oracle.
• Smith 2018 — D. G. A. Smith et al., Psi4NumPy: an interactive quantum chemistry programming environment for reference implementations and rapid development, J. Chem. Theory Comput. 14, 3504 (2018). 10.1021/acs.jctc.8b00286. The reference-implementation philosophy this challenge follows.
• Hirata 2003 — S. Hirata, Tensor Contraction Engine: abstraction and automated parallel implementation of configuration-interaction, coupled-cluster, and many-body perturbation theories, J. Phys. Chem. A 107, 9887 (2003). 10.1021/jp034596z. The other canonical route to general-order CC: symbolic derivation plus code generation.

No repository files or tests are named. Start with Level 0 by using PySCF's fcidump.from_scf and reference solvers to generate FCIDUMP and JSON data for the small systems, then implement and compare the Rust results; completion ultimately requires the FCI engine and arbitrary-order CC validated against PySCF and the cited Hirata tables.