QREChem: quantum resource estimation software for chemistry applications

Abstract

As quantum hardware continues to improve, more and more application scientists have entered the field of quantum computing. However, even with the rapid improvements in the last few years, quantum devices, especially for quantum chemistry applications, still struggle to perform calculations that classical computers could not calculate. In lieu of being able to perform specific calculations, it is important have a systematic way of estimating the resources necessary to tackle specific problems. Standard arguments about computational complexity provide hope that quantum computers will be useful for problems in quantum chemistry but obscure the true impact of many algorithmic overheads. These overheads will ultimately determine the precise point when quantum computers will perform better than classical computers. We have developed QREChem to provide logical resource estimates for ground state energy estimation in quantum chemistry through a Trotter-based quantum phase estimation approach. QREChem provides resource estimates which include the specific overheads inherent to problems in quantum chemistry by including heuristic estimates of the number of Trotter steps and number of necessary ancilla, allowing for more accurate estimates of the total number of gates. We utilize QREChem to provide logical resource estimates for a variety of small molecules in various basis sets, obtaining estimates in the range of 10⁷–10¹⁵ for total number of T gates. We also determine estimates for the FeMoco molecule and compare all estimates to other resource estimation tools. Finally, we compare the total resources, including hardware and error correction overheads, demonstrating the need for fast error correction cycle times.

1 Introduction

Quantum chemistry is often quoted as a potential “killer app” for quantum computers, with grand targets such as solving nitrogen fixation (Reiher et al., 2017). While there is much promise for quantum computers in quantum chemistry, due to a potential for an exponential speed up in eigenvalue estimation in quantum chemistry via the quantum phase estimation (QPE) algorithm (Kitaev, 1997; Abrams and Lloyd, 1999), realistic resource estimates, both at the logical and physical level, point to extremely large numbers of quantum gates and qubits necessary for even small systems (Reiher et al., 2017; Kim et al., 2022). Alternate algorithms, more suited to near-term, noisy intermediate scale quantum (NISQ) (Preskill, 2018) devices, such as the variational quantum eigensolver (VQE) (Peruzzo et al., 2014), provide a potential reduction in gate depth, but add additional complexity in optimization (Menickelly et al., 2023) and still require substantial gate depth for more interesting, classically intractable systems. With fault-tolerant, error-corrected quantum computers capable of the required gate depth and numbers of qubits still potentially years away, accurate resource estimates will play a key role in understanding the progress of quantum algorithms and the trade-offs of various architectural choices. There already exists several tools for estimating resources to varying degrees of precision. For example, TFermion (Casares et al., 2022) provides estimates of a wide variety of quantum algorithms for quantum chemistry but relies on strict error bounds, sometimes greatly overestimating the resources for certain algorithms, while OpenFermion provides estimates of certain specific quantum chemistry methods and also provides some tools for estimating surface code overhead (McClean et al., 2020). Microsoft has released a ‘full-stack’ resource estimation framework and tool (Beverland et al., 2022), which allows for a more general resource estimation, including many potential hardware overheads.

Here, we detail QREChem, which provides accurate logical and physical resource estimates with a specific focus on quantum chemistry. Within QREChem we have implemented a detailed resource estimation of the Trotter algorithm (Ortiz et al., 2001; Babbush et al., 2015), using heuristic, rather than worst-case, estimates for various algorithmic overheads. We have also included minimal implementations of error correction and hardware overheads. To benchmark our method, we compare our logical resource estimates to both TFermion (Casares et al., 2022) and OpenFermion (McClean et al., 2020) by estimating the total number of logical T gates for various small molecules and for the larger FeMoco molecule (Reiher et al., 2017). We additionally estimate the total physical resources needed, assuming various hardware and error correction parameters, for QREChem’s Trotter resource estimates.

QREChem was developed in mind as a tool for providing realistic estimations of resources to simulate ab initio quantum chemistry calculations on various quantum computers, both existing and future ones. It serves multiple purposes, with a primary goal of eventual co-design of future quantum computers and development of new quantum algorithms. For example, given a molecule, QREChem will be able to predict the resources (the number of qubits, gates, fidelities, sampling rate) required to accurately estimate the ground state energy. Or another way around given quantum hardware and molecule, QREChem could calculate a potential success rate. The current version of QREChem focuses on the algorithmic implementations; further development will involve adding more detailed implementations for the hardware and error correction overheads to provide more precise estimates.

2 Methods

2.1 Design of QREChem

QREChem is designed to allow for efficient and accurate logical resource estimates of ground state energy calculations in quantum chemistry problems. Figure 1 details the overall design. QREChem consists of several modules: the ‘Chemistry’ module, which defines the chemical system of interest; the ‘Algorithm’ module, which defines the quantum algorithm to be used; the ‘Hardware’ module, which defines the target hardware; and the ‘Error Correction’ module, which defines the quantum error correcting code. These modules work in tandem to produce the final resource estimates. Our primary focus in this work was to provide detailed implementations of the ‘Chemistry’ and ‘Algorithm’ (focusing on Trotterization algorithms (Ortiz et al., 2001; Babbush et al., 2015)) modules; the ‘Hardware’ and ‘Error Correction’ modules are relatively simple, by comparison. In the following sections, we provide detailed descriptions of each module, as implemented in the initial version QREChem, as well as ways in which each module can be further developed.

FIGURE 1

2.1.1 Chemistry module

The first step in performing quantum chemistry calculations is to generate the chemical Hamiltonian, which describes the energy operator of the molecular system in terms of the positions of its constituent atoms. In the Chemistry module of QREChem, we generate the Hamiltonian using the self-consistent field (SCF) methods implemented in the PySCF program (Sun et al., 2018; Sun et al., 2020).

The Hamiltonian matrix elements, which represent the contributions of the various terms in the Hamiltonian, are defined in terms of one-electron integrals, h_pq, and two-electron integrals, h_pqrs (Low et al., 2019). These integrals depend on the molecular properties such as the atomic coordinates, the charge, and the choice of basis set. SCF calculations, such as the restricted Hartree-Fock (RHF) method, are performed to obtain the one- and two-electron integrals for the chosen molecular system. QREChem requires the definition of the chemical system of interest, in terms of the atomic coordinates, the charge, and the target basis set.

It is important to note that the SCF calculations can be time-consuming, especially for larger numbers of atoms and larger basis sets, and can be tricky to properly converge. However, QREChem supports the standard fcidump file format, which stores the one- and two-electron integrals, allowing a user to generate these integrals using a different program and then interface with the other modules of QREChem. The fcidump file format is a widely used format for storing quantum chemistry Hamiltonians (Knowles and Handy, 1989) and can be produced by other quantum chemistry packages, such as Gaussian (Foresman and Frish, 1996), MolPro (Werner et al., 2012), or Psi4 (Smith et al., 2020). Once the one- and two-electron integrals are obtained, the data is available to other modules within QREChem.

2.1.2 Algorithm module

There are many proposed quantum algorithms for solving for the ground state energy in chemical problems, including quantum phase estimation (QPE) (Kitaev, 1997; Abrams and Lloyd, 1999), the variational quantum eigensolver (VQE) (Peruzzo et al., 2014), combinations of the two (Otten et al., 2022; D’Cunha et al., 2023), and quantum machine learning methods (Xia and Kais, 2018). Within each of these families of algorithms, there are a substantial number of possible variations. In this work, we focus on QPE using Trotterization (Ortiz et al., 2001; Babbush et al., 2015). Here, we provide a brief overview of QPE using Trotterization.

QPE solves for the eigenvalue, λ_k, for an eigenvector |v_k⟩ of some unitary matrix, U. Aside from its use in ground state energy estimation in quantum chemistry, it also finds use in Shor’s prime number factoring algorithm (Shor, 1999) and the Hassidim–Harrow–Lloyd algorithm for matrix inversion (Harrow et al., 2009). Given a Hamiltonian generated by the Chemistry module, the unitary matrix, U is can be written as:where τ is a scale factor to map the eigenvalues of Hτ onto (0, 2π] or (-π, π]. Assuming |v_k⟩ is the ground state, the ground state energy is then mapped to the phase acquired, E = 2πϕ/τ, where units have been chosen such that ℏ = 1. The computational complexity of QPE is dependent on how the unitary matrix of Eq. 1 is implemented. In QREChem, we focus on Trotterization (Ortiz et al., 2001; Babbush et al., 2015), but many other strategies, such as Taylorization (Berry et al., 2015) and qubitization (Low and Chuang, 2019) have been proposed. The Trotterized version of the propagator, U, is

By choosing some finite number of Trotter steps, n, U is only represented approximately. A first-order Trotter formula truncates Eq. (2) at some number of steps. Choosing a sufficient number of Trotter steps for a given accuracy is important for obtaining an accurate estimate of the total resources. Higher-order Trotter-Suzuki formulas (Suzuki, 1993) can be used to decrease the number of steps at the cost of increasing the complexity of each step. The standard fermionic quantum chemistry Hamiltonian has O(N⁴) terms. A fermion-to-spin mapping is required to implement each fermionic term on qubits. Using the Jordan–Wigner (Jordan and Wigner, 1993) transformation introduces an O(N) overhead, leading to a total complexity of O(N⁵) for the Trotterized evolution. The evolution of the phase is mapped to an ancilla register (introducing limits on the precision, based upon the number of ancilla) and, using the quantum Fourier transform (QFT) (Shor, 1994), the ground state energy can be read out. In realistic settings, the true eigenstate |v_k⟩ is unknown and an approximation must be used. This introduces an additional overhead in the success probability which scales as the overlap of the approximate state, |ϕ⟩, with the true eigenstate, i.e., |⟨ϕ|v_k⟩|².

Within QREChem, we provide resource estimates for Trotterized QPE by first estimating the resources required for a single Trotter time step and then estimating the total number of Trotter steps. The resource estimation tools within Microsoft Quantum Development Kit (QDK) (Svore et al., 2018; Low et al., 2019) are able to efficiently provide such logical gate estimates, even for very large systems. We estimate the total number of Trotter steps necessary as , where n_o is the number of orbitals used in the Hamiltonian which is based on heuristic estimates (Poulin et al., 2015; Reiher et al., 2017). Beyond number of Trotter steps, we also need to accurately compute the number of ancilla necessary to reach the a user-defined desired precision ϵ_p (which, by default, we take to be 1 mHa). This allows us to calculate the base number of binary digits necessary, n_b = −log₂(ϵ_p/ΔE_R), where ΔE_R is a scaling factor that estimates the spectral range (i.e., ΔE_R ≈ E_max − E_min) (D’Cunha et al., 2023) and is taken to be 1 Ha (a number chosen heuristically to cover all studied molecules). The phase resulting from a QPE is given as a binary fraction and the number of bits in this fraction (the precision) is determined by the number of ancilla qubits used in the QPE algorithm. If the eigenvalue is not exactly representable with n_b bits of precision, the returned value will, instead, be mapped into the finite precision of n_b bits, causing a chance for error. To increase the QPE success probability, additional ancilla can be used. If the eigenvector is known precisely, the total number of ancilla, n_a, is a function of the desired failure probability, p_f (Nielsen and Chuang, 2000),

It is very unlikely to know the true eigenstate a priori. More accurate formulas can be derived which take into account errors in the Trotterization, ϵ_t, as well as the true gap ΔE = E₁ − E₀ (Li, 2022)

Since the true gap, ΔE, is generally unknown, we instead use equation-of-motion (EOM) coupled-cluster with singles and doubles (CCSD) as implemented in PySCF (Sun et al., 2018) to estimate the gap. In cases where CCSD becomes too expensive, other methods with tunable cost and accuracy, such as selected configuration interaction (Chien et al., 2018) (which can be as cheap as Hartree-Fock) can be used. We also use a target Trotter error of chemical accuracy (ϵ_t = 1.6 mHa), rather than an observed Trotter error.

To calculate the total number of rotation gates, CNOT gates, and the total depth, we combine the estimates for a single Trotter step (using Q# and the Microsoft QDK) with the estimate of the total number of Trotter steps and multiply that by the number of ancilla, n_a, as each ancilla will require evolution to some long time, giving, for example, the total number of rotation gateswhere n_r is the number of rotation gates for a single Trotter step. Similar equations are used for the total depth and total number of CNOTs.

Using the same Hamiltonians generated in the Chemistry module, we utilized TFermion (Casares et al., 2022) and OpenFermion (McClean et al., 2020) to provide comparison logical resource estimates. TFermion provides estimates of a variety of quantum algorithms, including variants of Trotterization (Campbell, 2019) and Taylorization (Babbush et al., 2016), among others. It uses properties of the computed Hamiltonians, such as the 1-norm, combined with analytic formulas derived from the literature. OpenFermion provides estimation of more advanced algorithms, such as qubitization with low rank factorization (Berry et al., 2019).

Future improvements to the Algorithm module would involve the implementation of resource estimates for other evolution algorithms with explicit circuit constructions, such as qubitization and Taylorization, as well as other algorithms, such as VQE. Furthermore, overheads relating to the preparation of sufficient overlap initial states will also be implemented.

2.1.3 Error correction module

Quantum error correction (QEC) is an essential feature of any viable quantum computing system due to the intrinsic susceptibility of quantum systems to errors. These errors can be caused by a variety of factors, including decoherence and operational imperfections. In simple terms, QEC codes encode a logical qubit into several physical qubits, and through the process of measurement and classical post-processing, corrects the inevitable errors, extending the effective processing time before errors destroy the quantum state.

There are many proposed codes within QEC. Among them, the surface code (Fowler et al., 2012) stands out due to its high error threshold, relative ease of implementation, and planar geometry, which matches many proposed quantum architectures. Like any QEC code, the implementation of surface code necessitates a large number of physical qubits to encode a single logical qubit and presents a significant overhead in terms of resource requirements. Various implementations of the surface code have a given distance, d, which refers to the minimum number of physical qubits that must be affected by errors in order to cause a logical error. Within QREChem, we provide estimates of the QEC space and time overheads of the surface code using OpenFermion (McClean et al., 2020). The surface code cost estimator takes in the number of Toffoli gates, the number of logical qubits, a physical error rate, and the estimated surface code cycle time. It then estimates the total error, including error contributions from both magic state distillation (which is necessary to produce the Toffoli gates) (Litinski, 2019a) and due to the physical error rate. The physical error rate, p_P, logical error rate, p_L, and distance are approximately related via (Fowler and Gidney, 2018; Webber et al., 2022)

The total error and space-time (number of qubits times number of seconds) is estimated for a various distances d of the surface code. The best, in terms of space-time, distance d estimate which has total error below a threshold ϵ_sc (which we by default take to be 0.1) is returned as the optimal surface code.

QREChem allows a user to input the desired total algorithmic success probability. Along with the total depth, which is estimated in the Algorithm module, and the physical error rate and cycle time, which is provided by the Hardware module, the error correction module provides the best surface code distance d. This provides an initial estimate of the QEC overhead in terms of the number of physical qubits and total runtime. Future module development will include more accurate estimates of the overhead in numbers of gates needed for the surface code (via, for example, the methods in Ref (Litinski, 2019b).), as well as estimates for other QEC codes (such as color codes (Litinski et al., 2017)).

2.1.4 Hardware module

The underlying quantum computing architecture plays a pivotal role in the overall resource estimates. Various quantum hardware can have vastly different error rates, gate times, connectivities, native gate sets, etc (Menickelly et al., 2023). The Hardware module captures several hardware-specific factors that can significantly affect the performance and resources of quantum algorithms. Within the initial release of QREChem, the Hardware module consists of a high-level description of the underlying hardware, including gate times and physical error rates. With this simplistic Hardware module, we estimate the logical depth by assuming that all single qubit gates can be performed in parallel batches using n_o, the number of orbitals, qubits, and the CNOT gates cannot be performed in parallel (, where n_r is the number of rotation gates and n_c is the number of CNOTs). To estimate the number of T gates n_t, which are likely to be the most expensive gate for fault-tolerant, error-corrected quantum computers (Bravyi and König, 2013; Beverland et al., 2016), we use estimates of the circuit synthesis cost of arbitrary rotations from Clifford + T gates (Selinger, 2015)where ϵ_ss is the synthesis error, which we take to be 10^–9. We choose this value of the threshold to keep the synthesis error well below the standard bound, where N_g is the number of gates (Hastings, 2016), for all circuits studied. This is a tunable parameter which can be varied by a user. Total runtime is computed by interfacing with the Error Correction module, which requires a surface code cycle time, physical error rate, number of Toffoli gates (which is related to the number of T gate) and number of logical qubits. In the initial release of QREChem, we use experimentally demonstrated cycle times to abstract away the hardware details.

Future development of this module will incorporate underlying connectivity, specific noise models, and compilation to native gate sets, along with gate times, to computer the surface code cycle time, as it is evident from the results of this work that a fault-tolerant quantum computer will be required to execute QPE quantum circuits.

3 Results

3.1 Benchmark molecules

Using QREChem, TFermion, and OpenFermion, we estimated the required logical quantum resources for the Trotter-based QPE algorithm to compute the ground state properties of various small molecules, including H₂, HF, H₂O, NH₃, CH₄, Be₂, and C₂. The geometries of these molecules were taken from the NIST database (Johnson, 2022). For these molecules, we investigated the relationship between the number of orbitals and the quantum resources by considering several Gaussian-type orbital basis sets for the smaller molecules (STO-6G, 6-31G*, cc-pVDZ, and cc-pVTZ). All orbitals were included in the active space. These small molecule benchmarks represent some of the most commonly found molecules, while stressing different types of molecular bonding. The choice of basis sets follows a progression of complexity, starting from where Gaussian orbitals are fit to a single Slater orbital (STO-6G) (Stewart, 1970), to more complete basis functions (6-31G*) (Ditchfield et al., 1971) to more consistent basis sets designed for converging post-Hartree-Fock calculations (cc-pVDZ, cc-pVTZ) (Dunning, 1989) to the complete basis set limit.

We also consider the much larger FeMoco molecule, also known as the iron-molybdenum cofactor, which is crucial for biological nitrogen fixation; however, its fixation mechanism is not fully understood (Reiher et al., 2017). FeMoco is a well-known benchmark molecule that has been used in previous resource estimations. To compare our results with those of other studies, we used the same Hamiltonians (i.e., active spaces) as used in (Reiher et al., 2017) and (Li et al., 2019).

3.2 Resource estimates

Using QREChem, we obtained the total number of logical T gates necessary for various algorithms for each molecule at different basis set levels. The data for all molecules is shown in Figure 2. “This Work” represents the QREChem estimate of number of Trotter gates, as described above. “SF” uses OpenFermion’s resource estimation tools for the single factorization algorithm (Berry et al., 2019) to estimate the number of Toffoli gates, which is then scaled by 4, as that is the number of T gates necessary for one Toffoli gate (Berry et al., 2019). “TF-Trot” uses TFermion (Casares et al., 2022) to estimate the number of T gates in the qDRIFT algorithm (Campbell, 2019) and “TF-SF” uses TFermion to estimate the single factorization algorithm. Most striking is the comparison between TFermion’s Trotter algorithm (“TF-Trot”) and the one estimated in QREChem (“This Work”). This is likely due to the fact the qDRIFT estimates use worst-case error bounds to calculate the total number of operations. In QREChem’s Trotter estimates, we instead use heuristic estimates, which result in orders of magnitude lower number of necessary Trotter steps and, thus, orders of magnitude lower resource estimates. Furthermore, QREChem uses explicit gate counting provided by the Microsoft QDK, rather than the more pessimistic estimates used in the formula of TFermion. These more realistic estimates put Trotter close to the estimates of the more advanced single factorization algorithm (which requires additional ancilla qubits).

FIGURE 2

We further compare the resource estimates of the number of logical T gates for various algorithms using FeMoco, which is the standard benchmark molecule for evaluation of quantum algorithms. We used the same Hamiltonian as in previous studies (Reiher et al., 2017; Li et al., 2019) to obtain a precise comparison with other works. Table 1 shows the comparison of the number of T gates between QREChem’s Trotter estimation (“This Work”) and others from (Reiher et al., 2017; Berry et al., 2019; Casares et al., 2022). Ref (Reiher et al., 2017). provided the first theoretical estimates for FeMoco, which were approximately 10¹⁵ T gates. Again, we see that QREChem’s Trotter estimation lines up with the estimation from Ref. (Reiher et al., 2017), which is reasonable, given that both works used similar heuristic estimates. The single factorization algorithm (Berry et al., 2019) performs the best out of those studied.

All estimates presented in Figure 2 and Table 1 are only for the number of logical T gates required, not including additional overheads from hardware or error correction. To provide more realistic estimates, we estimated the surface code overhead for two benchmark systems: a superconducting qubit system and a trapped ion system. To parameterize the hardware, we use slight variations of parameters from recent demonstrations of error correction in each system (Chen et al., 2021; Ryan-Anderson et al., 2021), which are summarized in Table 2. The results are plotted in Figure 3 for our benchmark small molecules. The much lower error rates of the trapped ion system used (3e-5 vs. 5e-4 for the superconducting qubit system) allow for smaller surface code distances, d, and, hence, smaller numbers of physical qubits. The total runtime is several orders of magnitude higher, due to the increased cycle time (70 ms vs. 1μs for the superconducting qubit system). This leads to several orders of magnitude increase in the total space-time (measured in qubit-seconds) of the algorithm. These results point to the need for fast cycle times to achieve reasonable runtimes for quantum chemistry algorithms on quantum computers. Tabulated data for both physical qubit count and total runtime can be found in the Supplementary Materials for both architectures.

FIGURE 3

The data used in Figure 2 in collated in tabular form in the Supplementary Materials. Further tables, including our parameter settings, the number of rotation and CNOT gates and the number of physical qubits and runtime assuming a surface code error correction scheme on both superconducting qubit and trapped ion hardware can also be found in the Supplementary Materials as can details about the code and how to reproduce the results. The code is available from https://github.com/Argonne-QIS/QREChem/.

4 Discussion

We utilized the QREChem to provide accurate logical and physical resource estimations of a simple Trotter based algorithm over a broad range of molecules. Our heuristic-based Trotter estimates offers a more realistic estimate of the true cost of using Trotter, compared with more pessimistic estimates based on worst case bounds. On large systems such as the FeMoco molecule, the resource estimates are still large and do not include the necessary overheads of initial state preparation. The initial estimates of the overheads of quantum error correction and hardware limitations are significant and point to the need to have fast operations.

Accurate logical resource estimates, as currently implemented in QREChem, is a necessary first step for the larger goal of co-desiging future fault-tolerant quantum quantum computers capable of executing high-depth quantum chemistry circuits. Co-design allows for the optimization of both the hardware and algorithmic aspects of future quantum computers to facilitate the optimization of performance, scalability, accuracy, and energy efficiency. Moreover, co-design using a future version of QREChem will ensure that the simulation algorithms are tailored to the specific characteristics of the target quantum computers, ultimately enabling more effective and realistic quantum simulations. Future developments will include a detailed examination and implementation of advanced features in the Hardware and Error Correction modules, as well as inclusion of additional quantum algorithms. These enhancements will allow QREChem to continue to provide accurate, comprehensive, and actionable resource estimates for quantum chemistry.

References

• 1

  AbramsD. S.LloydS. (1999). Quantum algorithm providing exponential speed increase for finding eigenvalues and eigenvectors. Phys. Rev. Lett.83, 5162–5165. 10.1103/PhysRevLett.83.5162

  • CrossRef
  • Google Scholar
  • View reference in article

• 2

  BabbushR.BerryD. W.KivlichanI. D.WeiA. Y.LoveP. J.Aspuru-GuzikA. (2016). Exponentially more precise quantum simulation of fermions in second quantization. New J. Phys.18, 033032. 10.1088/1367-2630/18/3/033032

  • CrossRef
  • Google Scholar
  • View reference in article

• 3

  BabbushR.McCleanJ.WeckerD.Aspuru-GuzikA.WiebeN. (2015). Chemical basis of Trotter–Suzuki errors in quantum chemistry simulation. Phys. Rev. A91, 022311. 10.1103/PhysRevA.91.022311

  • CrossRef
  • Google Scholar
  • View reference in article

• 4

  BerryD. W.ChildsA. M.CleveR.KothariR.SommaR. D. (2015). Simulating Hamiltonian dynamics with a truncated taylor series. Phys. Rev. Lett.114, 090502. 10.1103/PhysRevLett.114.090502

  • CrossRef
  • Google Scholar
  • View reference in article

• 5

  BerryD. W.GidneyC.MottaM.McCleanJ. R.BabbushR. (2019). Qubitization of arbitrary basis quantum chemistry leveraging sparsity and low rank factorization. Quantum3, 208. 10.22331/q-2019-12-02-208

  • CrossRef
  • Google Scholar
  • View reference in article

• 6

  BeverlandM. E.BuerschaperO.KoenigR.PastawskiF.PreskillJ.SijherS. (2016). Protected gates for topological quantum field theories. J. Math. Phys.57, 022201. 10.1063/1.4939783

  • CrossRef
  • Google Scholar
  • View reference in article

• 7

  BeverlandM. E.MuraliP.TroyerM.SvoreK. M.HoefflerT.KliuchnikovV.et al (2022). Assessing requirements to scale to practical quantum advantage. arXiv preprint arXiv:2211.07629.

  • Google Scholar
  • View reference in article

• 8

  BravyiS.KönigR. (2013). Classification of topologically protected gates for local stabilizer codes. Phys. Rev. Lett.110, 170503. 10.1103/physrevlett.110.170503

  • CrossRef
  • Google Scholar
  • View reference in article

• 9

  CampbellE. (2019). Random compiler for fast Hamiltonian simulation. Phys. Rev. Lett.123, 070503. 10.1103/physrevlett.123.070503

  • CrossRef
  • Google Scholar
  • View reference in article

• 10

  CasaresP. A.CamposR.Martin-DelgadoM. A. (2022). Tfermion: a non-Clifford gate cost assessment library of quantum phase estimation algorithms for quantum chemistry. Quantum6, 768. 10.22331/q-2022-07-20-768

  • CrossRef
  • Google Scholar
  • View reference in article

• 11

  ChenZ.SatzingerK. J.AtalayaJ.KorotkovA. N.DunsworthA.SankD.et al (2021). Exponential suppression of bit or phase flip errors with repetitive error correction. arXiv preprint arXiv:2102.06132.

  • Google Scholar
  • View reference in article

• 12

  ChienA. D.HolmesA. A.OttenM.UmrigarC. J.SharmaS.ZimmermanP. M. (2018). Excited states of methylene, polyenes, and ozone from heat-bath configuration interaction. J. Phys. Chem. A122, 2714–2722. 10.1021/acs.jpca.8b01554

  • CrossRef
  • Google Scholar
  • View reference in article

• 13

  D’CunhaR.OttenM.HermesM. R.GagliardiL.GrayS. K. (2023). State preparation in quantum algorithms for fragment-based quantum chemistry. arXiv preprint arXiv:2305.18110.

  • Google Scholar
  • View reference in article

• 14

  DitchfieldR.HehreW. J.PopleJ. A. (1971). Self-consistent molecular-orbital methods. IX. An extended Gaussian-type basis for molecular-orbital studies of organic molecules. J. Chem. Phys.54, 724–728. 10.1063/1.1674902

  • CrossRef
  • Google Scholar
  • View reference in article

• 15

  DunningT. H. (1989). Gaussian basis sets for use in correlated molecular calculations. i. the atoms boron through neon and hydrogen. J. Chem. Phys.90, 1007–1023. 10.1063/1.456153

  • CrossRef
  • Google Scholar
  • View reference in article

• 16

  ForesmanJ.FrishE. (1996). Exploring chemistry. Pittsburg, USA: Gaussian Inc.

  • Google Scholar
  • View reference in article

• 17

  FowlerA. G.GidneyC. (2018). Low overhead quantum computation using lattice surgery. arXiv preprint arXiv:1808.06709.

  • Google Scholar
  • View reference in article

• 18

  FowlerA. G.MariantoniM.MartinisJ. M.ClelandA. N. (2012). Surface codes: towards practical large-scale quantum computation. Phys. Rev. A86, 032324. 10.1103/physreva.86.032324

  • CrossRef
  • Google Scholar
  • View reference in article

• 19

  HarrowA. W.HassidimA.LloydS. (2009). Quantum algorithm for linear systems of equations. Phys. Rev. Lett.103, 150502. 10.1103/PhysRevLett.103.150502

  • CrossRef
  • Google Scholar
  • View reference in article

• 20

  HastingsM. B. (2016). Turning gate synthesis errors into incoherent errors. arXiv preprint arXiv:1612.01011.

  • Google Scholar
  • View reference in article

• 21

  JohnsonR. D. (2022). NIST computational chemistry and comparison and benchmark database, NIST standard reference database number 101, release 22. Avaliable at: https://cccbdb.nist.gov.

  • Google Scholar
  • View reference in article

• 22

  JordanP.WignerE. P. (1993). über das paulische äquivalenzverbot The Collected Works of Eugene Paul WignerHeidelberg: Springer Berlin, 109–129.

  • Google Scholar
  • View reference in article

• 23

  KimI. H.LiuY. H.PallisterS.PolW.RobertsS.LeeE. (2022). Fault-tolerant resource estimate for quantum chemical simulations: case study on li-ion battery electrolyte molecules. Phys. Rev. Res.4, 023019. 10.1103/physrevresearch.4.023019

  • CrossRef
  • Google Scholar
  • View reference in article

• 24

  KitaevA. Y. (1997). Quantum computations: algorithms and error correction. Russ. Math. Surv.52, 1191–1249. 10.1070/RM1997v052n06ABEH002155

  • CrossRef
  • Google Scholar
  • View reference in article

• 25

  KnowlesP. J.HandyN. C. (1989). A determinant based full configuration interaction program. Comput. Phys. Commun.54, 75–83. 10.1016/0010-4655(89)90033-7

  • CrossRef
  • Google Scholar
  • View reference in article

• 26

  LeeJ.BerryD. W.GidneyC.HugginsW. J.McCleanJ. R.WiebeN.et al (2021). Even more efficient quantum computations of chemistry through tensor hypercontraction. PRX Quantum2, 030305. 10.1103/PRXQuantum.2.030305

  • CrossRef
  • Google Scholar
  • View reference in article

• 27

  LiX. (2022). Some error analysis for the quantum phase estimation algorithms. J. Phys. A Math. Theor.55, 325303. 10.1088/1751-8121/ac7f6c

  • CrossRef
  • Google Scholar
  • View reference in article

• 28

  LiZ.LiJ.DattaniN. S.UmrigarC.ChanG. K. L. (2019). The electronic complexity of the ground-state of the femo cofactor of nitrogenase as relevant to quantum simulations. J. Chem. Phys.150, 024302. 10.1063/1.5063376

  • CrossRef
  • Google Scholar
  • View reference in article

• 29

  LitinskiD. (2019a). Magic state distillation: not as costly as you think. Quantum3, 205. 10.22331/q-2019-12-02-205

  • CrossRef
  • Google Scholar
  • View reference in article

• 30

  LitinskiD. (2019b). A game of surface codes: large-scale quantum computing with lattice surgery. Quantum3, 128. 10.22331/q-2019-03-05-128

  • CrossRef
  • Google Scholar
  • View reference in article

• 31

  LitinskiD.KesselringM. S.EisertJ.von OppenF. (2017). Combining topological hardware and topological software: color-code quantum computing with topological superconductor networks. Phys. Rev. X7, 031048. 10.1103/physrevx.7.031048

  • CrossRef
  • Google Scholar
  • View reference in article

• 32

  LowG. H.BaumanN. P.GranadeC. E.PengB.WiebeN.BylaskaE. J.et al (2019). Q# and nwchem: tools for scalable quantum chemistry on quantum computers. arXiv preprint arXiv:1904.01131.

  • Google Scholar
  • View reference in article

• 33

  LowG. H.ChuangI. L. (2019). Hamiltonian simulation by qubitization. Quantum3, 163. 10.22331/q-2019-07-12-163

  • CrossRef
  • Google Scholar
  • View reference in article

• 34

  McCleanJ. R.RubinN. C.SungK. J.KivlichanI. D.Bonet-MonroigX.CaoY.et al (2020). OpenFermion: the electronic structure package for quantum computers. Quantum Sci. Technol.5, 034014. 10.1088/2058-9565/ab8ebc

  • CrossRef
  • Google Scholar
  • View reference in article

• 35

  MenickellyM.HaY.OttenM. (2023). Latency considerations for stochastic optimizers in variational quantum algorithms. Quantum7, 949. 10.22331/q-2023-03-16-949

  • CrossRef
  • Google Scholar
  • View reference in article

• 36

  NielsenM. A.ChuangI. L. (2000). Quantum computation and quantum informationCambridge: Cambridge University Press.

  • Google Scholar
  • View reference in article

• 37

  OrtizG.GubernatisJ. E.KnillE.LaflammeR. (2001). Quantum algorithms for fermionic simulations. Phys. Rev. A64, 022319. 10.1103/PhysRevA.64.022319

  • CrossRef
  • Google Scholar
  • View reference in article

• 38

  OttenM.HermesM. R.PandharkarR.AlexeevY.GrayS. K.GagliardiL. (2022). Localized quantum chemistry on quantum computers. J. Chem. Theory Comput.18, 7205–7217. 10.1021/acs.jctc.2c00388

  • CrossRef
  • Google Scholar
  • View reference in article

• 39

  PeruzzoA.McCleanJ.ShadboltP.YungM. H.ZhouX. Q.LoveP. J.et al (2014). A variational eigenvalue solver on a photonic quantum processor. Nat. Commun.5, 4213. 10.1038/ncomms5213

  • CrossRef
  • Google Scholar
  • View reference in article

• 40

  PoulinD.HastingsM. B.WeckerD.WiebeN.DobertyA. C.TroyerM. (2015). The Trotter step size required for accurate quantum simulation of quantum chemistry. Quantum info. comput.15, 361–384. 10.26421/qic15.5-6-1

  • CrossRef
  • Google Scholar
  • View reference in article

• 41

  PreskillJ. (2018). Quantum computing in the nisq era and beyond. Quantum2, 79. 10.22331/q-2018-08-06-79

  • CrossRef
  • Google Scholar
  • View reference in article

• 42

  ReiherM.WiebeN.SvoreK. M.WeckerD.TroyerM. (2017). Elucidating reaction mechanisms on quantum computers. Proc. Natl. Acad. Sci.114, 7555–7560. 10.1073/pnas.1619152114

  • CrossRef
  • Google Scholar
  • View reference in article

• 43

  Ryan-AndersonC.BohnetJ. G.LeeK.GreshD.HankinA.GaeblerJ.et al (2021). Realization of real-time fault-tolerant quantum error correction. Phys. Rev. X11, 041058. 10.1103/physrevx.11.041058

  • CrossRef
  • Google Scholar
  • View reference in article

• 44

  SelingerP. (2015). Efficient Clifford+T approximation of single-qubit operators. Quantum info. comput.15, 159–180. 10.26421/qic15.1-2-10

  • CrossRef
  • Google Scholar
  • View reference in article

• 45

  ShorP. (1994). “Algorithms for quantum computation: discrete logarithms and factoring,” in Proceedings 35th Annual Symposium on Foundations of Computer Science, Santa Fe, NM, USA, 20-22 November 1994 (IEEE), 124–134. 10.1109/SFCS.1994.365700

  • CrossRef
  • Google Scholar
  • View reference in article

• 46

  ShorP. W. (1999). Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Rev.41, 303–332. 10.1137/S0036144598347011

  • CrossRef
  • Google Scholar
  • View reference in article

• 47

  SmithD. G.BurnsL. A.SimmonettA. C.ParrishR. M.SchieberM. C.GalvelisR.et al (2020). Psi4 1.4: open-source software for high-throughput quantum chemistry. J. Chem. Phys.152, 184108. 10.1063/5.0006002

  • CrossRef
  • Google Scholar
  • View reference in article

• 48

  StewartR. F. (1970). Small Gaussian expansions of slater-type orbitals. J. Chem. Phys.52, 431–438. 10.1063/1.1672702

  • CrossRef
  • Google Scholar

• 49

  SunQ.BerkelbachT. C.BluntN. S.BoothG. H.GuoS.LiZ.et al (2018). PySCF: the Python-based simulations of chemistry framework. Wiley Interdiscip. Rev. Comput. Mol. Sci.8, e1340. 10.1002/wcms.1340

  • CrossRef
  • Google Scholar

• 50

  SunQ.ZhangX.BanerjeeS.BaoP.BarbryM.BluntN. S.et al (2020). Recent developments in the pyscf program package. J. Chem. Phys.153, 024109. 10.1063/5.0006074

  • CrossRef
  • Google Scholar

• 51

  SuzukiM. (1993). Improved trotter-like formula. Phys. Lett. A180, 232–234. 10.1016/0375-9601(93)90701-z

  • CrossRef
  • Google Scholar

• 52

  SvoreK.GellerA.TroyerM.AzariahJ.GranadeC.HeimB.et al (2018). “Q#: enabling scalable quantum computing and development with a high-level dsl,” in Proceedings of the real world domain specific languages workshop 2018 (New York, NY, USA: Association for Computing Machinery), RWDSL2018. 10.1145/3183895.3183901

  • CrossRef
  • Google Scholar

• 53

  WebberM.ElfvingV.WeidtS.HensingerW. K. (2022). The impact of hardware specifications on reaching quantum advantage in the fault tolerant regime. AVS Quantum Sci.4, 013801. 10.1116/5.0073075

  • CrossRef
  • Google Scholar

• 54

  WernerH. J.KnowlesP. J.KniziaG.ManbyF. R.SchützM. (2012). Molpro: a general-purpose quantum chemistry program package. Wiley Interdiscip. Rev. Comput. Mol. Sci.2, 242–253. 10.1002/wcms.82

  • CrossRef
  • Google Scholar

• 55

  XiaR.KaisS. (2018). Quantum machine learning for electronic structure calculations. Nat. Commun.9, 4195. 10.1038/s41467-018-06598-z

  • CrossRef
  • Google Scholar