Quantum Algorithms for Chemistry and Materials

Quantum chemistry and materials science do not define one computational problem and therefore do not select one quantum algorithm. A ground-state energy, an excitation gap, a finite-temperature correlation function, and a transport coefficient have different input states, output estimators, error mechanisms, and classical comparators. The durable conclusion is methodological: a credible proposal must match a finite physical model, data-access interface, scientific output, accuracy target, hardware regime, complete resource boundary, and dated classical baseline.

An exact fermion-to-qubit transformation does not remove basis-set, active-space, pseudopotential, or downfolding error. Conversely, solving a deliberately reduced Hamiltonian accurately can still be scientifically useful when that reduced model and its validation are stated. Phase estimation can deliver controlled eigenvalue precision, but only after paying for state overlap and coherent controlled evolution. A variational eigensolver exchanges some coherent depth for repeated preparation, measurement, classical optimization, and retry costs; none of those costs disappears by calling the circuit “near term.” A materials claim generally requires more than one encoded total energy: the measured quantity may require many geometries, momenta, frequencies, twists, field values, or thermodynamic extrapolations.

This page builds an auditable interface between electronic-structure modeling and quantum algorithms. It does not duplicate the canonical derivations of the molecular Hamiltonian, VQE, quantum phase estimation, or Hamiltonian simulation. Instead, it asks what must be recorded before results from those tools license a chemistry or materials conclusion. This restrained interpretation follows the broad reviews by McArdle et al. (2020) and Bauer et al. (2020), while treating present performance and future advantage as evidence-dependent rather than automatic.

Required background. The many-particle Hamiltonians page supplies creation and annihilation operators, occupation-number sectors, and two-body Hamiltonians. Algorithmic primitives supplies amplitude, oracle, and query-language distinctions. Hamiltonian simulation algorithms supplies product-formula, linear-combination, block-encoding, and qubitization interfaces used below.

Helpful background. The canonical accounts of quantum chemistry simulation, quantum materials simulation, and the electronic-structure overview provide physical context. This page owns the cross-cutting algorithm-selection and claim-audit framework, not those subjects’ full physical derivations or empirical case histories.

Scientific Questions Before Algorithm Names

Begin with the scientific observable and the decision it informs. “Find the ground-state energy” is still incomplete: one must say which nuclear geometry, basis, relativistic approximation, charge and spin sector, active space, and tolerance are intended. A chemical barrier is an energy difference along a reaction path, so systematic cancellation and the number of geometries matter. An equilibrium structure additionally needs forces or repeated energy evaluations. A spectral line may require an excited-state energy and transition matrix element, while a response function requires time evolution or a resolvent over a range of frequencies.

Materials problems multiply these interfaces. A phase diagram can require several candidate phases, cell sizes, twists or momenta, and finite-size extrapolation. A quasiparticle gap is not interchangeable with a finite-cell total-energy difference. Conductivity and magnetic response involve correlation functions, analytic continuation or spectral broadening, and often finite-temperature preparation. The low-depth materials constructions of Babbush et al. (2018) and the fault-tolerant Bloch-orbital study of Rubin et al. (2023) illustrate useful algorithmic structure, but each conclusion remains tied to a specified representation and task.

A sensible order of work is therefore: define the physical question; make the finite approximation explicit; state the required input state and observable; choose a representation; select a solver compatible with the hardware regime; propagate all errors to the scientific quantity; and compare total resources with a matched classical portfolio. Starting from an attractive circuit and asking afterward what it computes reverses the dependency.

The Eleven-Field Chemistry-and-Materials Claim Record

The following record is a compact test for whether a proposed result can be reproduced and interpreted. Every row must be instantiated; a phrase such as “standard assumptions” is not a substitute for values, construction rules, or cited procedures.

Field	Required record
Scientific question	Physical observable or decision, including the molecular geometry, material phase, control parameters, and why the requested precision matters
Finite model	Basis, cell or lattice, boundary conditions, effective-core or relativistic treatment, interaction truncation, and nuclear approximation
Instance and sector	Coefficients or reproducible generator, particle number, charge, spin or symmetry sector, and instance count
Representation and access	First or second quantization, fermion encoding, orbital ordering, block encoding or term oracle, coefficient precision, and data-loading cost
Input state	Preparation circuit or algorithm, target-state overlap or fidelity evidence, and whether ancillas or postselection are required
Algorithmic route	VQE, adaptive VQE, phase estimation, dynamics, response, or hybrid composition, with all hyperparameters
Measured output	Energy estimator, transition amplitude, correlation function, spectral feature, force, or derived property and its estimator
Accuracy and confidence	Error decomposition, confidence or failure probability, convergence tests, and any bias-versus-variance distinction
Complete resource boundary	State preparations, controlled evolutions, oracle calls, logical gates and qubits, compilation constants, shots, optimizer work, retries, and physical assumptions
Matched classical comparator	Same finite model, observable, tolerance, confidence, hardware accounting, and a portfolio of relevant classical methods
Evidence and licensed conclusion	Theorem, exact finite audit, classical emulation, device experiment, resource estimate, or end-to-end benchmark, followed by the narrow conclusion it supports

For a molecular energy claim, an instance might be a neutral molecule at a fixed geometry in a named orbital basis and active space, with a ground-state energy tolerance and confidence. The record must then include the preparation overlap, the number of geometries if a barrier is derived, and a classical method evaluated on that same Hamiltonian. For a materials observable, an instance might be a finite periodic cell at a named twist and momentum, but the scientific output could require a family of such instances plus finite-size and spectral inference. One successful eigenvalue calculation does not silently supply that outer workload.

The record separates reproducibility from optimism. A future fault-tolerant design may use projected logical-gate costs, provided the code family, physical error assumptions, factory model, and decoder assumptions remain visible. A device experiment may demonstrate a circuit primitive, provided it is not relabeled as a scientifically predictive benchmark. The negative-results and limitations case studies are the appropriate home for broader empirical lessons; the table here is the canonical claim schema for this algorithmic bridge.

Finite Hamiltonians as the Algorithmic Interface

Molecular electronic Hamiltonians

After fixing nuclear positions and a finite orthonormal spin-orbital basis, a common electronic Hamiltonian is

$$H = E_{\mathrm{nuc}} +\sum_{p q} h_{p q}a_p^\dagger a_q +\frac{1}{4}\sum_{p q r s} \langle p q\Vert r s\rangle a_p^\dagger a_q^\dagger a_s a_r .$$

Here $\langle p q\Vert r s\rangle$ denotes antisymmetrized two-electron integrals. If non-antisymmetrized Coulomb integrals are used instead, the conventional prefactor and index arrangement change, often to a factor $1/2$; mixing that convention with the $1/4$ expression double counts or mis-signs terms. $E_{\mathrm{nuc}}$ is a fixed scalar only within the clamped-nuclei approximation and at the stated geometry. Integral generation, basis orthogonalization, truncation, and coefficient rounding are part of the problem definition, even if a quantum circuit receives only the resulting coefficients.

Mode $p$ is the $p$th spin orbital in a fixed order, with $\{a_p,a_q^\dagger\}=\delta_{pq}$ and all other elementary anticommutators zero. Changing that order changes Pauli strings after encoding but not the finite fermionic operator.

This finite Hamiltonian is not “the molecule” without qualification. Basis incompleteness, neglected relativity, the Born–Oppenheimer approximation, frozen nuclear motion, and environmental modeling can dominate a millihartree-scale solver tolerance. Early phase-estimation proposals such as Aspuru-Guzik et al. (2005) established an important algorithmic route, while the application-level accuracy still depends on this preceding model interface.

Periodic and effective materials Hamiltonians

A minimal lattice interface may instead be the Hubbard Hamiltonian

$$H_{\mathrm{Hub}} = -t\sum_{\langle i,j\rangle,\sigma} \left( c_{i\sigma}^\dagger c_{j\sigma} +c_{j\sigma}^\dagger c_{i\sigma} \right) +U\sum_i n_{i\uparrow}n_{i\downarrow}.$$

The graph, hopping convention, boundary conditions, filling, spin sector, and whether $t$ or $U$ have been fitted or downfolded are indispensable metadata; inhomogeneous hoppings, phases, and site potentials define further variants rather than implicit details. An ab initio periodic calculation has a different finite interface: Bloch orbitals or localized orbitals, $k$-point sampling, a supercell, pseudopotentials, Coulomb finite-size treatment, and a convention for crystal momentum. These choices determine both the physical approximation and exploitable algorithmic structure.

An effective Hamiltonian can be the right scientific object. For example, a low-energy spin model can test a mechanism without pretending to predict every material property. The claim must then concern that effective model unless comparison with experiment or higher-level calculations establishes the mapping back to the material. “Quantum simulation of a material” is too broad when the executable problem is one small, fitted lattice instance.

First- and second-quantized interfaces

Second quantization assigns occupation information to modes and is natural when a selected orbital basis and variable particle sectors matter. First quantization assigns registers to particles and represents antisymmetry through the state; it can expose different sparsity and arithmetic structures. Su et al. (2021) give a fault-tolerant first-quantized chemistry construction, while many VQE and qubitization workflows begin in second quantization.

Within either quantization, the one-particle representation still changes the interface. A finite molecular-orbital or localized-orbital calculation must give both spatial-orbital and spin-orbital counts and the rule used to construct them. A plane-wave or plane-wave-dual calculation must state the simulation cell, boundary convention, kinetic-energy cutoff, resulting basis size, and the locality-versus-diagonality trade exposed by the dual transform. A Bloch-orbital description labels crystal momentum, band, and spin, permits generally complex integrals, and preserves momentum only modulo a reciprocal-lattice vector. A localized-Wannier or downfolded description must disclose localization and disentanglement windows, screening and truncation, and any double-counting correction.

Neither quantization nor basis family is universally superior. Qubit width, antisymmetrization, state preparation, integral or potential access, oracle construction, block-encoding normalization, compiled evolution, basis convergence, and observable extraction must be compared for the same finite task. A first-quantized asymptotic expression that assumes efficient coherent data access cannot fairly be compared with a second-quantized compiled estimate that charges every lookup. Likewise, diagonal kinetic energy in one basis may be exchanged for local interactions in its dual. The representation is an algorithmic interface with costs, not merely a notation change.

Fermion-to-Qubit Mappings

Jordan–Wigner convention

Fix a mode ordering $0,1,\ldots,M-1$ and let $|n_0n_1\cdots n_{M-1}\rangle$ denote the occupation basis. With the convention used here,

$$a_p = \left(\prod_{j<p} Z_j\right) \frac{X_p+iY_p}{2}, \qquad n_p=a_p^\dagger a_p=\frac{I-Z_p}{2}.$$

The parity string enforces fermionic anticommutation; omitting it makes operators on different modes commute. The mapping introduced by Jordan and Wigner (1928) is exact on the finite Fock space. It stores occupations locally, but a creation or annihilation operator can have support linear in the ordering distance. The canonical Jordan–Wigner transformation page owns the fuller derivation.

Signs depend jointly on the basis-label convention, qubit endianness, and mode ordering. A finite audit should therefore construct matrices in a stated basis, not rely only on a remembered Pauli formula. The first reproducible audit below does this for two modes and also verifies the conserved fermion parity.

Bravyi–Kitaev information sets

The Bravyi–Kitaev family stores combinations of occupation, parity, and update information so that the standard tree construction gives logarithmic-support update and parity sets. It is also an exact finite-dimensional encoding. The original framework is due to Bravyi and Kitaev (2002); Seeley, Richard, and Love (2012) develop its use for electronic structure.

Logarithmic elementary support is not a universal compiled advantage. Transformed Hamiltonian weight distributions, cancellation, commuting structure, routing, native gates, tapering, and coefficient thresholds all affect the realized circuit and measurement cost. A fair statement is conditional: for a specified orbital ordering, Hamiltonian, compiler, architecture, and cost metric, one encoding produced a measured reduction.

Ordering, connectivity, and compiled cost

Orbital ordering is part of the mapping algorithm. Localized orbitals ordered along a hardware path may shorten important Jordan–Wigner strings; a chemically intuitive ordering may instead expose symmetry or measurement grouping. Bravyi–Kitaev trees can likewise be shaped or permuted. The comparison should report the pre- and post-taper qubit count, Pauli-term count and weight distribution, two-qubit gates after routing, depth, measurement groups, and any optimization budget spent finding the ordering.

Encoding	Stored information	Elementary support	Useful structure	Hidden or instance-dependent cost	Fair comparison
Jordan–Wigner	One occupation bit per qubit	Local number operators; creation and hopping strings can scale linearly with ordering distance	Transparent occupations, parity sectors, and simple finite audits	Orbital ordering, Pauli cancellation, routing, and long strings	Compile the same tapered Hamiltonian under stated orderings and architecture
Parity	Prefix or cumulative fermion parity	Some parity operations simplify while occupation updates spread	Particle-parity information and selected symmetry reductions	Basis convention, update support, sector handling, routing, and transformed observables	Hold the sector, coefficients, tapering rules, compiler, and metric fixed
Bravyi–Kitaev	Tree-organized occupation, parity, and update sets	Standard constructions give logarithmic update and parity support	Balances occupation and parity access; admits multiple trees	Tree choice, Hamiltonian weight distribution, routing, grouping, and compiler behavior	Report instance-level logical and compiled metrics; do not infer a universal winner from support alone

Hamiltonian equivalence is necessary but not sufficient. State-preparation circuits and measured observables must be transformed under the same convention. A qubit Hamiltonian paired with an untransformed fermionic observable can return a precise answer to the wrong measurement problem.

Active Spaces, Downfolding, and Symmetry Reduction

Frozen cores and active orbitals

Freezing core orbitals and selecting an active set can reduce both qubits and interaction terms. A reproducible definition names the parent one-particle basis, orbital construction, frozen occupations, active electrons and orbitals, and the scalar and one-body shifts induced by integrating out frozen modes. It also states whether orbitals were optimized for one geometry or transferred across a scan.

This reduction is a model choice, not a solver acceleration that leaves the target Hamiltonian unchanged. Convergence should be checked against enlarged active spaces or a trusted embedding or many-body method at representative instances. If a reaction energy uses several geometries, a discontinuously changing active space can introduce artifacts even when each individual variational optimization converges.

Downfolding changes the target

Let $P$ project onto a chosen low-energy subspace. Simply solving $P H P$ exactly does not by itself control the error relative to eigenvalues of $H$:

$$\|H-PHP\|$$

is generally not small merely because $P$ has modest dimension, and couplings through $Q=I-P$ can produce energy-dependent effective interactions. Perturbative downfolding, canonical transformations, constrained random-phase approximations, and fitted lattice models introduce distinct assumptions. Each must be validated in the regime where the final property is claimed.

This distinction blocks a common overclaim: arbitrarily precise phase estimation on an aggressively downfolded Hamiltonian cannot repair downfolding bias. The output may still be an excellent benchmark for that effective Hamiltonian. The licensed conclusion must name it.

Symmetry sectors and qubit tapering

Exact commuting symmetries can reduce the encoded space. A tapering record should identify mutually commuting Pauli generators, their eigenvalues for the target sector, the Clifford transformation or equivalent construction, the removed qubits, and the transformation of every measured observable. The method of Bravyi et al. (2017) makes this reduction systematic for suitable $\mathbb Z_2$ symmetries.

Exact symmetry is different from approximate conservation. Fixing electron-number parity is exact when the Hamiltonian commutes with it and the target sector is known. Projecting onto an approximate spin or point-group label after symmetry-breaking approximations may change the model and needs an error assessment. Tapering the wrong eigenvalue sector removes the desired state entirely; additional solver precision then only confirms the wrong sector.

State Preparation and Target Overlap

Reference and multiconfigurational states

A single Slater determinant is often an economical reference near weakly correlated equilibrium geometries. Bond breaking, transition-metal complexes, excited states, and strongly correlated materials may require multiconfigurational references, adiabatic preparation, selected configuration interaction, tensor-network states, imaginary-time-inspired procedures, or variationally optimized preparations. Fomichev et al. (2024) survey and analyze state-preparation strategies in a fault-tolerant chemistry context.

Preparation resources include more than the final circuit depth. One must charge classical preprocessing, coefficient storage or coherent loading, amplitude synthesis, success probability, postselection, uncomputation, and repetitions after a failed eigenvalue projection. If the proposed state is obtained by a classical method already accurate enough to answer the requested observable, that fact belongs in the comparator analysis rather than being hidden as “free initialization.”

Overlap controls projection cost

For an eigenbasis $H|E_k\rangle=E_k|E_k\rangle$, write

$$|\phi\rangle=\sum_k c_k|E_k\rangle, \qquad p_0=|\langle E_0|\phi\rangle|^2=|c_0|^2 .$$

Ideal phase estimation samples the target eigenphase with probability $p_0$ per independent preparation. After $R$ attempts, the probability of at least one target hit is

$$P_{\mathrm{hit}}=1-(1-p_0)^R.$$

For $0<p_0<1$, requiring failure probability at most $\delta$ gives

$$R \ge \left\lceil \frac{\ln\delta}{\ln(1-p_0)} \right\rceil .$$

The endpoints must be handled separately: $p_0=0$ makes success impossible for any finite $R$, while $p_0=1$ requires one attempt when $\delta<1$. An overlap estimate is therefore not decorative metadata. It multiplies state-preparation and controlled-evolution work, and uncertainty in it can dominate a resource range.

Ground, excited, thermal, and dynamical inputs

Different outputs require different states. Ground-state energy estimation needs target overlap but does not automatically prepare a reusable ground state after all measurement and uncomputation choices. Excited-state work needs symmetry selection, deflation, filtering, response operators, or labeled initial states, together with a rule for resolving nearby levels. Thermal observables require purification, Gibbs-state preparation, sampling, or a justified ensemble approximation. Real-time response begins from a state on which an operator has acted, so the relevant norm and spectral weights change.

State preparation and output extraction must be designed together. Preparing an excellent ground-state approximation is insufficient for an absorption spectrum if the transition operator, excited-state overlaps, and frequency resolution are not included. Conversely, a broad state with many eigencomponents can be useful for spectral sampling even though its ground-state overlap is small.

Phase Estimation and Fault-Tolerant Energy Algorithms

Energy-to-phase conversion

Under this site’s convention,

$$U|u_k\rangle=e^{+2\pi i\phi_k}|u_k\rangle .$$

If the simulated unitary is

$$U=\exp[-i(H-E_{\mathrm{ref}})\tau],$$

then the decoded phase is

$$\phi_k = -\frac{(E_k-E_{\mathrm{ref}})\tau}{2\pi} \pmod 1 .$$

The minus sign is essential. An energy window and reference must be chosen so that modular phases are unaliased; otherwise distinct energies can map to the same phase. Given an unwrapped representative,

$$E_k=E_{\mathrm{ref}}-\frac{2\pi\phi_k}{\tau},$$

with the correct integer branch fixed by the promised window. The phase-estimation page owns the circuit derivation; chemistry resource records must expose this decoder and window.

Precision, normalization, and controlled evolution

Resolving energy on a grid $\epsilon_E$ requires total coherent evolution scale proportional to $1/\epsilon_E$ in the basic Fourier picture. If a promised interval has width $W$ and $m$ binary phase bits span it, the grid is $W/2^m$ and the sum of controlled evolution times in the standard powers is

$$T_{\mathrm{int}} = \frac{2\pi}{W}\left(2^m-1\right).$$

This is an idealized interaction-time ledger, not a physical runtime. Synthesis accuracy, robust phase-estimation variants, confidence amplification, ancilla use, inverse-transform cost, and the implementation of controlled time evolution add resources. Energy shifts can improve phase placement but do not change spectral width; rescaling changes both the phase relation and simulation normalization.

For a block encoding with normalization $\lambda$, a representative qubitization-style query scaling is

$$Q = O\!\left( \frac{\lambda}{\epsilon_E} \operatorname{polylog}\!\left( \frac{\lambda}{\epsilon_E} \right) \right).$$

Low-rank and tensor-factorized constructions can reduce $\lambda$ or the cost of implementing the encoding. The sparse arbitrary-basis construction of Berry et al. (2019) and tensor-hypercontraction estimates of Lee et al. (2021) show why the factorization and access model must be stated, not suppressed into big-$O$ notation.

Query cost is not runtime

A query invokes a precisely defined SELECT, PREPARE, walk, or time-evolution primitive. Its logical gate cost depends on coefficient precision, coherent memory or on-the-fly arithmetic, uncomputation, connectivity, control structure, and chosen error allocation. The total logical ledger further multiplies by overlap-dependent attempts and confidence amplification. Physical runtime additionally needs an error-correcting code, cycle time, logical failure target, magic-state factories, routing, parallelism, and scheduling.

The resource-estimation study of a chemical reaction mechanism by Reiher et al. (2017) was influential precisely because it made a chain of architectural assumptions visible. Later algorithmic improvements alter that chain; they do not justify comparing a modern query count with an old wall-clock number as if the units matched. The canonical resource-estimation tools page owns the software workflow. This page requires that chemistry and materials claims preserve each conversion layer.

VQE, ADAPT-VQE, and Measurement Work

Variational bounds and their scope

For a normalized trial state $|\psi(\boldsymbol\theta)\rangle$ and an exactly represented Hermitian Hamiltonian,

$$E(\boldsymbol\theta) = \langle\psi(\boldsymbol\theta)|H|\psi(\boldsymbol\theta)\rangle = \sum_{\ell=1}^{L}h_\ell \langle P_\ell\rangle_{\boldsymbol\theta} \ge E_0 .$$

This Rayleigh–Ritz upper bound applies to the exact expectation of the encoded Hamiltonian in the chosen sector. The photonic demonstration by Peruzzo et al. (2014) introduced the VQE architecture: a parameterized preparation, measured objective, and classical optimizer. The finite-shot estimate need not itself lie above $E_0$; readout mitigation, zero-noise extrapolation, postselection, nonlinear estimators, or optimizer selection can introduce bias. Nor does the bound relate $E(\boldsymbol\theta)$ directly to the physical complete-basis energy when the model is truncated.

The VQE resource is the whole optimization process: objective evaluations, circuits per objective, shots per circuit, gradients or surrogate fits, calibration, failed starts, stopping rules, and uncertainty after selection. Quoting only the depth of one ansatz evaluation omits the dominant repetition in many regimes.

Adaptive ansatz growth

ADAPT-VQE grows an ansatz by screening an operator pool, selecting one or more candidates, appending them, and reoptimizing. Grimsley et al. (2019) established the molecular algorithm. Its compact final ansatz can be valuable, but pool screening creates an outer measurement loop.

If $K$ operators are screened at each of $L$ growth steps using a two-shift parameter rule, the leading screening ledger contains

$$N_{\mathrm{families}}=2KL$$

shifted expectation families before multiplying by Hamiltonian groups, shots, repeated optimizer evaluations, or restarts. Commutator measurements or analytic identities can alter constants and grouping, but they must be specified. A comparison between ADAPT-VQE and a fixed ansatz must charge pool construction, screening, all intermediate reoptimizations, and the success criterion, not only the depth of the final circuit.

Groups, variances, and optimizer evaluations

For independently sampled Pauli terms with $S_\ell$ shots, let $\sigma_\ell$ be the standard deviation of a single-shot outcome, so its single-shot variance is $\sigma_\ell^2$. Then

$$\operatorname{Var}(\widehat E) = \sum_{\ell=1}^{L} \frac{h_\ell^2\sigma_\ell^2}{S_\ell}.$$

This formula supports variance-aware shot allocation, but grouping jointly measurable terms introduces covariances. The estimator variance then depends on the state, grouping rule, basis-change circuit, and allocation among groups. Crawford et al. (2021) analyze finite-sampling measurement design, while Huggins et al. (2021) demonstrate fermionic measurement strategies and noise-resilient considerations.

A complete count has at least four multipliers: groups per objective, shots per group, objective or gradient evaluations per optimization, and independent restarts or mitigation scale factors. Adaptive shot allocation makes these random variables rather than fixed constants. Reporting expected cost should be accompanied by stopping and tail criteria, because a few difficult restarts can control wall time and confidence.

Dynamics, Response, and Materials Observables

Real-time evolution and spectral resolution

Given an initial state, real-time simulation approximates $e^{-iHt}|\psi\rangle$ or observables along that trajectory. A frequency resolution $\Delta\omega$ generally requires observation times of order $1/\Delta\omega$, while a finite time window produces broadening and ringing. Trotter step size, qubitization error, synthesis error, decoherence, and sampling all enter before a spectrum is inferred. A claim should state the window function, time grid, maximum time, and frequency estimator rather than presenting a smoothed curve as a direct eigenvalue list.

The relevant cost is not always one evolution to $t_{\max}$. Separate time points may require fresh preparations; iterative or multitime protocols may require controlled evolution, ancillas, or amplitude estimation. Statistical error can grow after Fourier transformation, and weak spectral features require more samples than dominant peaks. Time-domain algorithms should therefore be compared at the requested spectral resolution and confidence, not at a single short evolution time.

Correlation functions and response

For operators $A$ and $B$, a zero-temperature correlation function has the form

$$C_{AB}(t) = \langle\psi|A(t)B(0)|\psi\rangle, \qquad A(t)=e^{+iHt}Ae^{-iHt}.$$

Measuring its real and imaginary parts may require interferometric controls, linear-combination decompositions, randomized estimators, or separate circuits. Finite-temperature response adds state-preparation and ensemble costs. Derived susceptibilities can require Fourier transformation, analytic continuation, normalization by system size, and subtraction of disconnected contributions. Each operation can amplify error or introduce regularization dependence.

Molecular observables beyond energies have equally important interfaces. Dipole moments, forces, densities, and transition strengths require transformed operators and sometimes response of optimized parameters. Steudtner et al. (2023) analyze fault-tolerant routes to molecular observables, underscoring that an eigenvalue oracle alone is not the entire measurement workflow.

One energy is not a material property

A finite-cell ground-state energy at one parameter point may be an ingredient in a material prediction, not the prediction itself. A phase boundary needs energy differences among phases across control parameters. An equation of state needs many volumes. A band or spectral function needs momenta and frequencies. A thermodynamic observable needs temperatures and finite-size control. A transport coefficient may require a low-frequency limit whose uncertainty is far more demanding than the underlying time samples.

The outer scientific loop belongs in the resource ledger. If a property uses $N_{\mathrm{cell}}$ cell sizes, $N_k$ momenta, $N_\omega$ frequency points, $N_T$ temperatures, and $N_{\mathrm{field}}$ perturbations, any assumed reuse or parallelism must be justified. Symmetry can reduce this product, interpolation can reduce explicit evaluations, and correlated sampling can improve differences, but none may be assumed silently. The materials case studies own instance-specific evidence; here the general rule is that resources scale with the scientific observable’s complete instance family.

Choosing a Solver Without Hiding the Interface

Match output and hardware regime

VQE is naturally an expectation-estimation and optimization workflow for devices unable to sustain long coherent controlled evolutions. It can exploit problem-informed ansätze, but its sampling and optimizer burden can be large and its accuracy certificate weak. ADAPT-VQE spends additional screening measurements to construct a compact ansatz. Fault-tolerant phase estimation offers a direct eigenphase estimator and systematic precision control, but requires adequate overlap and a costly coherent simulation interface. Real-time response targets correlation data rather than merely a lowest eigenvalue.

The hardware label is not enough to select among them. A shallow circuit with hundreds of millions of preparations may be slower or less reliable than a deeper, structured routine on a different architecture. Conversely, a favorable asymptotic phase-estimation query bound can be irrelevant before fault-tolerant data access and state preparation exist. Solver selection should be conditional on the complete record.

Representation–solver decision table

Route	Primary output	Input state	Coherence burden	Sampling or repetition burden	Dominant hidden interfaces	Licensed conclusion
VQE	Optimized expectation of a finite Hamiltonian; possibly other measured observables	Parameterized reference with an ansatz capable of reaching the target sector	Circuit depth per ansatz and measurement basis; no long controlled evolution required	Groups × shots × objective or gradient evaluations × total runs, plus mitigation	Ansatz bias, optimizer selection, measurement covariance, calibration, and model error	A bounded estimate for the stated encoded model under documented estimator assumptions
ADAPT-VQE	VQE objective with an iteratively selected operator sequence	Initial reference, operator pool, and screening rule	Growing state-preparation depth and screening circuits	Pool screens at each layer plus every reoptimization and final measurement	Pool completeness, gradient estimator, tie breaking, grouping, stopping rule, and failed growth paths	Performance of the declared adaptive procedure on the stated instances, not universal ansatz superiority
QPE with fault-tolerant simulation	Eigenphase or energy sample with controlled grid and failure probability	State with quantified overlap in the desired sector	Long controlled simulation, block encoding, arithmetic, and error correction	Overlap-dependent preparations and confidence repetitions	Phase window, normalization $\lambda$, PREPARE/SELECT cost, coefficient precision, factories, and decoding	Energy of the encoded Hamiltonian to the stated algorithmic precision, conditional on the implementation ledger
Real-time dynamics or response	Time samples, correlation functions, or inferred spectral data	Ground, thermal, perturbed, or otherwise task-specific state	Evolution to the maximum useful time, sometimes coherently controlled	Fresh states and measurements across times, operators, momenta, and components	Windowing, broadening, analytic continuation, weak-signal variance, and outer instance grid	The stated time-domain estimator or derived response within its resolution and inference assumptions

This table is not a ranking. Hybrid compositions are often appropriate: a variational or classical state can seed phase estimation; phase estimation can prepare an eigenstate for response; and classical embedding can define a quantum active-space subproblem. Each composition joins, rather than erases, the component interfaces and error budgets.

Error Budgets from Model to Observable

A seven-layer error ledger

An additive ledger is meaningful only after every contribution has been converted into a bound in one common observable-error metric. Declare a telescoping chain from the physical target through intermediate finite models, reduced spaces, prepared states, algorithmic outputs, compiled implementations, and inferred estimators; bound each adjacent change in the same final observable. The triangle inequality then gives the conservative decomposition

$$|\widehat O-O_{\mathrm{phys}}| \le \epsilon_{\mathrm{model}} +\epsilon_{\mathrm{space}} +\epsilon_{\mathrm{prep}} +\epsilon_{\mathrm{solver}} +\epsilon_{\mathrm{impl}} +\epsilon_{\mathrm{stat}} +\epsilon_{\mathrm{infer}} .$$

The terms respectively cover the physical model and discretization; active-space or downfolding choice; state preparation; algorithmic solver or simulation; compiled implementation; statistical estimation; and inference from raw estimators to the reported property. This is a bookkeeping bound, not a claim that each term is independently measurable or that the bound is tight. A rigorous norm bound, an empirical spread, and a guessed systematic uncertainty cannot be inserted as if they were interchangeable; each needs a label and a justified conversion to the declared observable metric.

Layer	Quantity controlled	Validation or bound	What later precision cannot repair
Physical model and discretization	Basis, cell, nuclei, relativity, environment, boundary conditions, and interaction model	Basis or cell convergence, higher-level theory, experiment where appropriate, and sensitivity studies	A Hamiltonian that omits physically relevant degrees of freedom or interactions
Active space or downfolding	Frozen modes, effective interactions, embedding bath, and retained subspace	Enlarged spaces, alternative downfoldings, perturbative estimates, or benchmark instances	Bias from a reduced target that excludes needed configurations
Exact encoding and symmetry sector	Fermion algebra, qubit convention, conserved generators, eigenvalues, and transformed observables	Finite matrix equality, anticommutators, spectra, commutators, and untapered comparisons	An exact mapping adds no approximation by itself, but a wrong sector or untransformed observable invalidates the result
State preparation	Fidelity or overlap with the ground, excited, thermal, or perturbed target	Classical overlap estimates, energy variance, symmetry checks, witness bounds, or calibrated success probabilities	Zero target overlap and missing spectral components
Solver and simulation	Ansatz error, phase grid, truncation, product formula, block encoding, and synthesis allocation	Convergence, residuals, phase-window checks, rigorous algorithmic bounds, and exact small-instance audits	Error inherited from earlier modeling layers
Compilation and hardware	Logical synthesis, routing, noise, error correction, and logical failure probability	Circuit equivalence, randomized tests, fault budgets, calibration, and architecture-specific simulation	A mismatched access oracle or underestimated implementation primitive
Measurement and inference	Shot noise, covariance, mitigation bias, fitting, transforms, continuation, and extrapolation	Confidence intervals, held-out synthetic data, resampling, coverage tests, and method variation	Missing observables, insufficient time or size ranges, and an ill-posed scientific estimator

Root-sum-square combination is justified only for approximately independent, zero-mean errors with defensible distributions. Many model and solver errors are biased or correlated. Correlated energy errors can cancel in reaction or phase differences, while independent shot noise may add; the direction and magnitude must be tested rather than assumed.

Derived properties and cancellation

Suppose a reaction energy is $\Delta E=E_B-E_A$. A common basis or method can produce cancellation, so bounding $|E_A-E_A^{\mathrm{phys}}|+|E_B-E_B^{\mathrm{phys}}|$ may be conservative. Yet using different active spaces, orbital roots, geometries, or stochastic stopping rules can destroy that cancellation. Covariance-aware sampling can reduce the variance of $\widehat E_B-\widehat E_A$ only when the estimators are coupled in a specified way.

For a derivative or extrapolated limit, small pointwise errors can be amplified. A force from a finite difference divides an energy difference by a displacement; a dc conductivity extrapolates toward zero frequency; a thermodynamic limit fits several sizes. The budget should be propagated through the actual estimator, with sensitivity to step size, fit range, regularization, and correlations. “Chemical accuracy” near $1\,\mathrm{kcal\,mol^{-1}}$ is a conventional energy scale, not a universal acceptance criterion for spectra, forces, phase boundaries, or materials response.

Resource Estimates and Matched Classical Baselines

Logical-to-physical assumptions

A logical resource table should identify logical qubits, non-Clifford gates or rotations, Clifford work when relevant, circuit depth, query definitions, peak workspace, state preparations, failure allocation, and opportunities for parallelism. A physical projection then adds the code family and distance, physical error rates and correlations, cycle time, decoder, factory design, routing, cooling or control constraints, and total success probability. Range estimates should vary consequential assumptions rather than report spurious significant digits.

For VQE-like workflows, the analogous physical boundary includes shot rate, reset and readout latency, calibration duty cycle, classical optimizer latency, queueing, and total independent runs. For phase estimation it includes state-preparation failures, all controlled calls, magic-state throughput, and logical checkpoint or retry policy. These are different resource dimensions; collapsing both into “circuit count” conceals rather than enables comparison.

Classical comparator portfolio

A matched baseline solves the same finite model for the same observable, accuracy, confidence, and instance family. Depending on regime, the portfolio can include exact diagonalization, determinant-space methods, coupled cluster, selected configuration interaction, density-matrix renormalization group or other tensor networks, quantum Monte Carlo with its sign and bias qualifications, dynamical mean-field or embedding methods, density-functional approximations, and specialized lattice solvers. The best comparator may change across molecular geometry, dimension, entanglement structure, and output type.

Classical preprocessing used by a quantum workflow must not be treated as free while comparator preprocessing is charged. Likewise, a classical method should not be required to produce a full wavefunction if the quantum claim asks only for one energy, nor may a quantum proposal claim the whole materials task after estimating one subproblem. The evidence analysis of ground-state chemistry by Lee et al. (2023) exemplifies why classical algorithmic progress and problem structure must remain visible in advantage claims.

Evidence labels and bounded conclusions

Evidence class	What is established	What remains conditional	Permitted wording
Algorithmic theorem	Correctness or asymptotic bound under explicit oracle, promise, precision, and success assumptions	Constants, access construction, state preparation, compilation, hardware, and practical crossover	“The algorithm has the stated bound under these assumptions”
Classical or tensor-network simulation	Exact or controlled behavior for the simulated finite instances and noise model	Scaling beyond tested sizes, hardware-specific effects, and scientific-model adequacy	“The method was validated on these instances to this tolerance”
Device demonstration	Execution and measured estimator on named hardware with a documented protocol	Fault-tolerant scaling, broad instance performance, model completeness, and advantage	“The device demonstrated this workflow at the reported scale and uncertainty”
Fault-tolerant resource estimate	Projected resources under a declared algorithm, compilation stack, and architecture model	Future component performance, assumption stability, state overlap, and classical crossover	“The estimate projects these resources under the stated assumptions”
End-to-end scientific benchmark	Performance on the same model, output, tolerance, instance family, and accounting boundary as comparators	Generalization outside the benchmark and future algorithmic changes	“This benchmark supports the bounded comparative conclusion reported here”

Evidence can be strong without being universal. A finite device experiment may establish implementation competence; a theorem may establish scaling; a resource estimate may identify bottlenecks; and a scientific benchmark may support a crossover for a narrow family. Combining them into a broader advantage claim requires that their assumptions and problem definitions align.

Three Reproducible Finite Audits

The following audits are deliberately small enough to derive by hand and execute without libraries. They verify finite algebra and declared ledgers only. They do not validate chemical realism, hardware performance, asymptotic advantage, or the classical comparator.

Audit 1 — A two-mode fermionic Hamiltonian

Consider

$$H = \epsilon_0 n_0+\epsilon_1 n_1 +t(a_0^\dagger a_1+a_1^\dagger a_0) +U n_0n_1$$

with $\epsilon_0=-1$, $\epsilon_1=0.5$, $t=0.25$, and $U=0.75$. In the ordered basis $\{|00\rangle,|01\rangle,|10\rangle,|11\rangle\}$, direct fermionic action gives

$$H_{\mathrm F} = \begin{pmatrix} 0&0&0&0\\ 0&0.5&0.25&0\\ 0&0.25&-1&0\\ 0&0&0&0.25 \end{pmatrix}.$$

The stated Jordan–Wigner convention gives

$$H_{\mathrm Q} = -0.0625I +0.3125Z_0 -0.4375Z_1 +0.1875Z_0Z_1 +0.125(X_0X_1+Y_0Y_1).$$

The vacuum energy is $0$, the double-occupation energy is $0.25$, and the one-particle block has eigenvalues

$$E_\pm=\frac{-0.5\pm\sqrt{2.5}}{2}.$$

Both matrices have trace $-0.25$ and commute with parity $Z_0Z_1$. Thus equality of matrices supplies the full spectral equality, while the independent trace, parity, and analytic-eigenvalue checks make common sign and ordering mistakes visible.

Audit 2 — Overlap, phase precision, and model error

Take $p_0=0.2$ and target failure $\delta=0.01$. The repetition formula gives

$$R_{\min} = \left\lceil \frac{\ln 0.01}{\ln 0.8} \right\rceil =21,$$

and $R=20$ still has failure $0.8^{20}>0.01$. For an unaliased width $W=8$ hartree and $m=13$ phase bits, the energy grid is

$$\Delta E=\frac{8}{2^{13}} =0.0009765625\ \mathrm{hartree},$$

and the idealized interaction-time sum is

$$T_{\mathrm{int}} = \frac{2\pi}{8}(2^{13}-1) =\frac{\pi}{4}\,8191.$$

Now declare a millihartree ledger: $4$ from model and active-space bias, $0.5$ from factorization, $0.7$ from simulation and synthesis, and $0.9765625$ from the phase grid. Its conservative total is $6.1765625$ millihartree. Refining phase estimation can reduce only the last solver-controlled contribution; it cannot remove the initial $4$ millihartree model term.

Audit 3 — Conditional VQE and QPE resource ledgers

For QPE route A, let $\lambda=40$ hartree, $\epsilon_E=0.001$ hartree, $p_0=0.25$, $\delta=0.01$, and declare $1000$ compiled units per query. The leading query ledger is $40{,}000$ per attempt, $17$ attempts, $680{,}000$ total queries, and $680{,}000{,}000$ compiled units. Route B has $\lambda=25$, the same $\epsilon_E$, $p_0=0.10$, $\delta=0.01$, and $1800$ units per query: $25{,}000$ per attempt, $44$ attempts, $1{,}100{,}000$ queries, and $1{,}980{,}000{,}000$ compiled units. Lower $\lambda$ does not win after overlap and implementation constants are included.

For a VQE ledger with $150$ measurement groups, $2000$ shots per group, $400$ objective evaluations per run, and $3$ total independent runs, the declared total is

$$150\times2000\times400\times3 =360{,}000{,}000$$

state preparations. A separate two-shift ADAPT screening declaration with $K=80$ pool operators and $L=12$ growth layers contains

$$2\times80\times12=1920$$

shifted expectation families before expanding each family into groups and shots. This is a stipulated ledger for that procedure, not a universal lower bound. VQE preparations, shifted families, QPE queries, and compiled units are different dimensions; these counts diagnose interfaces but do not declare a solver winner.

"use strict";

const tolerance = 1e-10;
const assert = (condition, message) => {
  if (!condition) throw new Error(message);
};
const close = (a, b, tol = tolerance) => Math.abs(a - b) <= tol;
const matrixClose = (a, b) =>
  a.every((row, i) => row.every((value, j) => close(value, b[i][j])));
const trace = (a) => a.reduce((sum, row, i) => sum + row[i], 0);

function symmetricEigenvalues(input) {
  const a = input.map((row) => row.slice());
  const n = a.length;
  for (let sweep = 0; sweep < 100; sweep += 1) {
    let p = 0;
    let q = 1;
    let largest = 0;
    for (let i = 0; i < n; i += 1) {
      for (let j = i + 1; j < n; j += 1) {
        if (Math.abs(a[i][j]) > largest) {
          largest = Math.abs(a[i][j]);
          p = i;
          q = j;
        }
      }
    }
    if (largest < 1e-14) break;
    const angle = 0.5 * Math.atan2(2 * a[p][q], a[q][q] - a[p][p]);
    const c = Math.cos(angle);
    const s = Math.sin(angle);
    const app = a[p][p];
    const aqq = a[q][q];
    const apq = a[p][q];
    for (let k = 0; k < n; k += 1) {
      if (k !== p && k !== q) {
        const akp = a[k][p];
        const akq = a[k][q];
        a[k][p] = a[p][k] = c * akp - s * akq;
        a[k][q] = a[q][k] = s * akp + c * akq;
      }
    }
    a[p][p] = c * c * app - 2 * s * c * apq + s * s * aqq;
    a[q][q] = s * s * app + 2 * s * c * apq + c * c * aqq;
    a[p][q] = a[q][p] = 0;
  }
  return a.map((row, i) => row[i]).sort((x, y) => x - y);
}

const fermionic = [
  [0, 0, 0, 0],
  [0, 0.5, 0.25, 0],
  [0, 0.25, -1, 0],
  [0, 0, 0, 0.25],
];
const mapped = Array.from({ length: 4 }, () => Array(4).fill(0));
for (let basis = 0; basis < 4; basis += 1) {
  const n0 = (basis >> 1) & 1;
  const n1 = basis & 1;
  const z0 = 1 - 2 * n0;
  const z1 = 1 - 2 * n1;
  mapped[basis][basis] =
    -0.0625 + 0.3125 * z0 - 0.4375 * z1 + 0.1875 * z0 * z1;
}
mapped[1][2] = mapped[2][1] = 0.25;
assert(matrixClose(fermionic, mapped), "Jordan-Wigner matrix mismatch");
assert(close(trace(fermionic), -0.25), "trace mismatch");
const parity = [1, -1, -1, 1];
for (let i = 0; i < 4; i += 1) {
  for (let j = 0; j < 4; j += 1) {
    assert(close((parity[i] - parity[j]) * mapped[i][j], 0), "parity mismatch");
  }
}
const exactSpectrum = [
  (-0.5 - Math.sqrt(2.5)) / 2,
  0,
  0.25,
  (-0.5 + Math.sqrt(2.5)) / 2,
].sort((a, b) => a - b);
for (const matrix of [fermionic, mapped]) {
  const spectrum = symmetricEigenvalues(matrix);
  spectrum.forEach((value, i) =>
    assert(close(value, exactSpectrum[i]), "spectrum mismatch")
  );
}

const repetitions = (p, delta) =>
  Math.ceil(Math.log(delta) / Math.log(1 - p));
const overlapRepetitions = repetitions(0.2, 0.01);
assert(overlapRepetitions === 21, "overlap repetition mismatch");
assert(0.8 ** overlapRepetitions <= 0.01, "failure target missed");
assert(0.8 ** (overlapRepetitions - 1) > 0.01, "repetition is not minimal");
const width = 8;
const bits = 13;
const grid = width / 2 ** bits;
const interactionTime = (2 * Math.PI / width) * (2 ** bits - 1);
assert(close(grid, 0.0009765625), "phase grid mismatch");
assert(close(interactionTime, (Math.PI / 4) * 8191), "time ledger mismatch");
const errorLedger = 4 + 0.5 + 0.7 + 0.9765625;
assert(close(errorLedger, 6.1765625), "error ledger mismatch");

const qpeA = {
  perAttempt: Math.ceil(40 / 0.001),
  attempts: repetitions(0.25, 0.01),
  unitsPerQuery: 1000,
};
const qpeB = {
  perAttempt: Math.ceil(25 / 0.001),
  attempts: repetitions(0.10, 0.01),
  unitsPerQuery: 1800,
};
qpeA.queries = qpeA.perAttempt * qpeA.attempts;
qpeB.queries = qpeB.perAttempt * qpeB.attempts;
assert(qpeA.perAttempt === 40000 && qpeA.attempts === 17, "QPE A setup");
assert(qpeA.queries === 680000, "QPE A query ledger");
assert(qpeA.queries * qpeA.unitsPerQuery === 680000000, "QPE A compiled ledger");
assert(qpeB.perAttempt === 25000 && qpeB.attempts === 44, "QPE B setup");
assert(qpeB.queries === 1100000, "QPE B query ledger");
assert(qpeB.queries * qpeB.unitsPerQuery === 1980000000, "QPE B compiled ledger");
const vqePreparations = 150 * 2000 * 400 * 3;
const adaptFamilies = 2 * 80 * 12;
assert(vqePreparations === 360000000, "VQE ledger mismatch");
assert(adaptFamilies === 1920, "ADAPT ledger mismatch");

console.log("Quantum-chemistry-and-materials finite audits: PASS");

Common Chemistry-and-Materials Claim Failures

Naming a molecule instead of defining an instance. A molecular formula does not fix geometry, isotope or nuclear treatment, charge, multiplicity, orbital basis, active space, or Hamiltonian coefficients. Repair the claim with a reproducible finite instance and separate physical-model convergence from solver convergence.

Calling an encoding approximate. Jordan–Wigner and Bravyi–Kitaev are exact encodings of the chosen finite fermionic Fock space. Approximation enters through the physical model, coefficient truncation, symmetry or sector mistakes, solver, and implementation. Compare encodings using compiled instance-level metrics rather than attributing model error to Pauli-string length.

Quoting one circuit evaluation as the algorithm cost. A VQE circuit is nested inside measurement groups, shots, optimizer or gradient evaluations, mitigation settings, and total independent runs. An ADAPT circuit adds screening and repeated reoptimization. State the multiplication ledger and stopping rule.

Suppressing state overlap in phase estimation. Precision controls phase resolution, not the probability that the prepared state occupies the desired eigenstate. Include preparation cost and overlap-dependent attempts; handle $p_0=0$ and $p_0=1$ separately.

Equating queries, logical gates, and wall time. Each conversion depends on a named block encoding, data-access method, compiler, architecture, error-correction design, throughput, and parallel schedule. Report these as layers with units instead of a single decontextualized number.

Promoting one energy to a materials prediction. The scientific property may require many cells, momenta, temperatures, perturbations, or times and a sensitive extrapolation. Expand that outer loop, propagate uncertainty through the final estimator, and compare with classical methods that target the same property.

Using “chemical accuracy” as a universal threshold. A conventional energy scale does not determine acceptable uncertainty for forces, weak spectral peaks, phase stability, or response. Justify tolerance from the scientific decision and show how each error layer contributes.

Claiming advantage from unmatched evidence. An asymptotic theorem, small device run, and projected resource estimate answer different questions. A comparative advantage claim needs the same finite problem, output, tolerance, confidence, resource boundary, and dated classical portfolio.

Exercises

1. Audit a fermion-mapping claim

A report says: “Bravyi–Kitaev is exponentially better than Jordan–Wigner because all of its fermionic operators have logarithmic Pauli weight.” Identify the invalid inference and replace it with an auditable comparison.

Solution

The standard Bravyi–Kitaev construction balances occupation, parity, and update sets so that elementary fermionic updates have logarithmic support, whereas a Jordan–Wigner update may carry a linear parity string. That statement does not imply an exponential improvement in an algorithm’s compiled cost. A Hamiltonian is a sum of products of elementary operators; terms can cancel, group, taper, or route differently. State preparation and observables also transform, and architecture-specific two-qubit routing can dominate.

An auditable replacement is: fix the same fermionic Hamiltonian, sector, coefficient threshold, and observable; choose and publish the orbital order and Bravyi–Kitaev tree; transform and taper both encodings; compile them with the same compiler and native gate set; and report qubits, Pauli-term weights, measurement groups, two-qubit gates, depth, routing, and compilation time. Then state only the observed conditional result, such as “Bravyi–Kitaev reduced routed two-qubit depth by this factor on these instances.” Both encodings remain exact before implementation error.

2. Separate active-space and solver error

A $12$-orbital calculation has an estimated $3.5$ millihartree active-space bias and a $0.8$ millihartree solver error. An improved solver reduces its own error to $0.1$ millihartree. Give a conservative total before and after, and state what conclusion is not licensed.

Solution

Using the additive ledger and omitting other layers only for this exercise, the initial bound is

$$3.5+0.8=4.3\ \mathrm{millihartree}.$$

After the solver improvement it is

$$3.5+0.1=3.6\ \mathrm{millihartree}.$$

The improvement is real for the encoded active-space Hamiltonian, but it does not make the physical result accurate to $0.1$ millihartree. The $3.5$ millihartree model-space term remains. Nor is root-sum-square combination justified without independent, zero-mean error models. A stronger physical conclusion requires enlarging or validating the active space, and a complete claim would restore basis, preparation, implementation, statistical, and inference terms.

3. Count an ADAPT-VQE screening workload

An ADAPT procedure screens $K=60$ operators for $L=10$ layers using two shifted families per operator. Each family uses $120$ commuting groups and $1500$ shots per group. Count shifted families and state preparations before reoptimization, final measurement, mitigation, or retry costs.

Solution

For the declared two-shift rule,

$$N_{\mathrm{families}}=2KL=2\times60\times10=1200.$$

Expanding each family gives

$$1200\times120\times1500 =216{,}000{,}000$$

state preparations. This is a stipulated screening ledger, not a universal lower bound: commutator identities, grouping, reuse, or another gradient estimator can change it. It is also not the total ADAPT-VQE cost. Each layer normally triggers reoptimization, which adds objective and gradient evaluations; the final observable needs its own precision; and independent total runs or mitigation scale factors multiply work. The result licenses only the stated pre-reoptimization screening count.

4. Budget overlap-sensitive phase estimation

Find the minimum independent attempts needed for failure at most $10^{-3}$ when $p_0=0.05$. Explain the cases $p_0=0$ and $p_0=1$, and identify which resource must be multiplied by the attempt count.

Solution

For $0<p_0<1$,

$$R_{\min} = \left\lceil \frac{\ln(10^{-3})}{\ln(0.95)} \right\rceil =135.$$

Indeed, the failure after $R$ independent preparations is $0.95^R$, so minimality is checked by verifying $0.95^{135}\le10^{-3}$ and $0.95^{134}>10^{-3}$. If $p_0=0$, the target component is absent and no finite repetition succeeds. If $p_0=1$, one attempt suffices for any nontrivial target failure probability. The attempt factor multiplies target-state preparations and the phase-estimation work performed per attempt, including controlled simulation and its compiled logical or physical resources. It does not improve the model or phase grid.

5. Compare two qubitization ledgers

Route C has $\lambda=60$, $\epsilon_E=0.002$, overlap $p_0=0.5$, failure target $\delta=0.01$, and $500$ compiled units per leading query. Route D has $\lambda=30$, the same precision, $p_0=0.2$, and $1200$ units per query. Use $Q_{\mathrm{attempt}}=\lceil\lambda/\epsilon_E\rceil$ and compare the declared ledgers. Does the result determine runtime?

Solution

Route C uses $30{,}000$ leading queries per attempt and

$$\left\lceil\frac{\ln0.01}{\ln0.5}\right\rceil=7$$

attempts. It therefore uses $210{,}000$ queries and $105{,}000{,}000$ compiled units. Route D uses $15{,}000$ queries per attempt and

$$\left\lceil\frac{\ln0.01}{\ln0.8}\right\rceil=21$$

attempts, for $315{,}000$ queries and $378{,}000{,}000$ compiled units. The smaller normalization does not win this declared composite ledger because overlap and per-query implementation differ.

The result does not determine runtime. “Compiled unit” needs a definition, and scheduling requires logical depth, qubits, factories, error correction, cycle time, parallelism, state-preparation latency, and retry policy. The comparison is conditional on the leading-query approximation as well.

6. Expand a single-layer materials estimate

A report quotes $10^6$ state preparations for one VQE optimization of one finite cell. The scientific result needs $4$ cell sizes, $8$ momenta, $3$ field values, $120$ measurement groups, $1000$ shots per group, $250$ optimizer evaluations, and $2$ total independent runs. Compute the fully expanded preparation count from the granular ledger and explain why the quoted number cannot simply be reused.

Solution

There are

$$4\times8\times3=96$$

scientific instances. The granular VQE ledger is

$$96\times120\times1000\times250\times2 =5.76\times10^9$$

state preparations. This count assumes every instance uses the same groups, shots, optimizer evaluations, and two total independent runs, with no cross-instance reuse or failures.

The quoted $10^6$ is not composable until its boundary is known. It might already include groups and shots, might describe only one objective, or might come from a different cell and tolerance. Multiplying it risks either omission or double counting. A resource claim must expose units and factors. The $5.76\times10^9$ result still excludes calibration, mitigation, classical preprocessing, parameter transfer, inference and finite-size fitting, and any varying difficulty among instances.

7. Match solvers to scientific outputs

Choose a plausible route for each task: (a) a ground-state energy with a fault-tolerant machine and a reference of known overlap, (b) several excited energies and transition strengths, and (c) a frequency-resolved response function. State one hidden interface for each.

Solution

For (a), phase estimation with fault-tolerant Hamiltonian simulation is plausible because it directly samples an eigenphase with controlled grid precision. Its hidden interfaces include the unaliased energy window, block-encoding normalization and compiled SELECT/PREPARE, and overlap-dependent attempts.

For (b), phase estimation can be combined with symmetry-selected or filtered inputs and explicit transition-operator measurement; subspace or response variants may also be appropriate. The hidden interface is not just energy resolution but preparation weight on each excited state and extraction of matrix elements. Ground-state QPE alone is insufficient.

For (c), real-time evolution and correlation measurement is a direct route. The hidden interface includes preparation of the perturbed or thermal state, controlled measurement of complex correlators, maximum time, windowing, shot variance, Fourier resolution, and possibly analytic continuation. VQE might prepare the initial state but does not by itself provide the response. These are plausible selections, not universal rankings.

8. Repair an overclaimed chemistry advantage

Repair this statement: “Our $20$-qubit VQE found the energy to chemical accuracy, proving quantum advantage for industrial chemistry.”

Solution

A defensible statement would identify the molecule and geometry; parent basis; frozen core and active electrons and orbitals; charge, spin, and tapered symmetry sector; transformed Hamiltonian and coefficients; ansatz, optimizer, grouping, shots, mitigation, stopping rule, and total independent runs. It would define whether “chemical accuracy” means estimator uncertainty, error against exact diagonalization of the active-space Hamiltonian, or error against a higher-level physical reference.

It would then report complete device and classical preprocessing resources and compare against a dated portfolio of classical methods on the same finite model, observable, tolerance, confidence, and hardware boundary. If the actual evidence is a device result agreeing with exact diagonalization of a $20$-qubit active-space Hamiltonian within a stated interval, the licensed conclusion is that this workflow reproduced that finite benchmark under the reported conditions. It does not by itself establish industrial relevance, physical-model accuracy, scaling, a crossover, or quantum advantage.

References

• A. Aspuru-Guzik, A. D. Dutoi, P. J. Love, and M. Head-Gordon, “Simulated Quantum Computation of Molecular Energies,” Science 309, 1704–1707 (2005), doi:10.1126/science.1113479.
• R. Babbush, N. Wiebe, J. McClean, J. McClain, H. Neven, and G. K.-L. Chan, “Low-Depth Quantum Simulation of Materials,” Physical Review X 8, 011044 (2018), doi:10.1103/PhysRevX.8.011044.
• B. Bauer, S. Bravyi, M. Motta, and G. K.-L. Chan, “Quantum Algorithms for Quantum Chemistry and Quantum Materials Science,” Chemical Reviews 120, 12685–12717 (2020), doi:10.1021/acs.chemrev.9b00829.
• D. W. Berry, C. Gidney, M. Motta, J. R. McClean, and R. Babbush, “Qubitization of Arbitrary Basis Quantum Chemistry Leveraging Sparsity and Low Rank Factorization,” Quantum 3, 208 (2019), doi:10.22331/q-2019-12-02-208.
• S. B. Bravyi and A. Yu. Kitaev, “Fermionic Quantum Computation,” Annals of Physics 298, 210–226 (2002), doi:10.1006/aphy.2002.6254.
• S. Bravyi, J. M. Gambetta, A. Mezzacapo, and K. Temme, “Tapering Off Qubits to Simulate Fermionic Hamiltonians,” arXiv:1701.08213 (2017), arXiv:1701.08213.
• O. Crawford, B. van Straaten, D. Wang, T. Parks, E. Campbell, and S. Brierley, “Efficient Quantum Measurement of Pauli Operators in the Presence of Finite Sampling Error,” Quantum 5, 385 (2021), doi:10.22331/q-2021-01-20-385.
• S. Fomichev, K. Hejazi, M. Shokrian Zini, M. Kiser, J. Fraxanet, P. A. Moreno Casares, A. Delgado, J. Huh, A.-C. Voigt, J. E. Mueller, and J. M. Arrazola, “Initial State Preparation for Quantum Chemistry on Quantum Computers,” PRX Quantum 5, 040339 (2024), doi:10.1103/PRXQuantum.5.040339.
• H. R. Grimsley, S. E. Economou, E. Barnes, and N. J. Mayhall, “An Adaptive Variational Algorithm for Exact Molecular Simulations on a Quantum Computer,” Nature Communications 10, 3007 (2019), doi:10.1038/s41467-019-10988-2.
• W. J. Huggins, J. R. McClean, N. C. Rubin, Z. Jiang, N. Wiebe, K. B. Whaley, and R. Babbush, “Efficient and Noise Resilient Measurements for Quantum Chemistry on Near-Term Quantum Computers,” npj Quantum Information 7, 23 (2021), doi:10.1038/s41534-020-00341-7.
• P. Jordan and E. Wigner, “Über das Paulische Äquivalenzverbot,” Zeitschrift für Physik 47, 631–651 (1928), doi:10.1007/BF01331938.
• J. Lee, D. W. Berry, C. Gidney, W. J. Huggins, J. R. McClean, N. Wiebe, and R. Babbush, “Even More Efficient Quantum Computations of Chemistry Through Tensor Hypercontraction,” PRX Quantum 2, 030305 (2021), doi:10.1103/PRXQuantum.2.030305.
• S. Lee, J. Lee, H. Zhai, Y. Tong, A. M. Dalzell, A. Kumar, P. Helms, J. Gray, Z.-H. Cui, W. Liu, M. Kastoryano, R. Babbush, J. Preskill, D. R. Reichman, E. T. Campbell, E. F. Valeev, L. Lin, and G. K.-L. Chan, “Evaluating the Evidence for Exponential Quantum Advantage in Ground-State Quantum Chemistry,” Nature Communications 14, 1952 (2023), doi:10.1038/s41467-023-37587-6.
• S. McArdle, S. Endo, A. Aspuru-Guzik, S. C. Benjamin, and X. Yuan, “Quantum Computational Chemistry,” Reviews of Modern Physics 92, 015003 (2020), doi:10.1103/RevModPhys.92.015003.
• A. Peruzzo, J. McClean, P. Shadbolt, M.-H. Yung, X.-Q. Zhou, P. J. Love, A. Aspuru-Guzik, and J. L. O’Brien, “A Variational Eigenvalue Solver on a Photonic Quantum Processor,” Nature Communications 5, 4213 (2014), doi:10.1038/ncomms5213.
• M. Reiher, N. Wiebe, K. M. Svore, D. Wecker, and M. Troyer, “Elucidating Reaction Mechanisms on Quantum Computers,” Proceedings of the National Academy of Sciences of the United States of America 114, 7555–7560 (2017), doi:10.1073/pnas.1619152114.
• N. C. Rubin, D. W. Berry, F. D. Malone, A. F. White, T. Khattar, A. E. DePrince III, S. Sicolo, M. Küehn, M. Kaicher, J. Lee, and R. Babbush, “Fault-Tolerant Quantum Simulation of Materials Using Bloch Orbitals,” PRX Quantum 4, 040303 (2023), doi:10.1103/PRXQuantum.4.040303.
• J. T. Seeley, M. J. Richard, and P. J. Love, “The Bravyi–Kitaev Transformation for Quantum Computation of Electronic Structure,” The Journal of Chemical Physics 137, 224109 (2012), doi:10.1063/1.4768229.
• M. Steudtner, S. Morley-Short, W. Pol, S. Sim, C. L. Cortes, M. Loipersberger, R. M. Parrish, M. Degroote, N. Moll, R. Santagati, and M. Streif, “Fault-Tolerant Quantum Computation of Molecular Observables,” Quantum 7, 1164 (2023), doi:10.22331/q-2023-11-06-1164.
• Y. Su, D. W. Berry, N. Wiebe, N. Rubin, and R. Babbush, “Fault-Tolerant Quantum Simulations of Chemistry in First Quantization,” PRX Quantum 2, 040332 (2021), doi:10.1103/PRXQuantum.2.040332.