Skip to content

QFD

Use Eigenproblem(A=...) with QFD(initial_state=..., time_step=..., powers=...) to estimate the smallest eigenvalue of A in a basis of time-evolved states V**p |psi>. Here psi is your reference state, V is one fixed product-formula step, by default of the nonidentity Pauli terms of A, and p runs over the integer powers you choose. The result reports the lowest projected Ritz value, the energy of the reference state, and the reference energy minus the Ritz value. The Ritz value does not certify the full-space ground energy.

from nwqlib import Eigenproblem, solve
from nwqlib.algorithms import QFD
from nwqlib.algorithms.qfd import chemistry_evolution_terms

Every object on this page imports from nwqlib.algorithms.qfd, and QFD and QFDResult also import from nwqlib.algorithms.

QFD solves the Hamiltonian pencil of Parrish and McMahon, arXiv:1909.08925v1, Sec. II.C, Eqs. (5)–(8), with the states of one fixed product-formula step in place of exact time evolution. It obtains the projected matrices H and S as FixedGCIM does, from joint states of an ancilla and the system, so the GCiM and ADAPT page documents the objects that the two methods share: PencilAcquisition, PencilSampling, ShotAllocation, ProjectedPencil and the matrix-element records that QFDResult holds.

Solve in a basis of evolved states

QFD

Bases: Method

Quantum filter diagonalization: the lowest Ritz energy of A in the basis of integer powers of one fixed product-formula step V.

Build it with keyword arguments and pass it as method=, for example solve(Eigenproblem(A=H), method=QFD(initial_state=psi, time_step=0.5, powers=(0, 1, 2)), shots=1000). initial_state, time_step and powers are required. Write A = c_I I + A0. The basis state of power p is phi_p = V**p |psi> for one fixed step V, which applies steps_per_time_step = r substeps of a product formula for time_step/r, of A0 by default or of the fermionic blocks of B0 with evolution="fermionic_blocks", with order 2 (the default) or order 1. A negative power applies the exact adjoint of V, its rotations in reverse order with negated angles. The result is a QFDResult whose eigenvalue is the lowest kept Ritz value of H f = E S f, with H_jk = <phi_j|A|phi_k> and S_jk = <phi_j|phi_k> measured for the original A, and whose reference_energy is <psi|A|psi>. This is the Hamiltonian pencil of Parrish and McMahon, arXiv:1909.08925v1, Sec. II.C, Eqs. (5)-(8), with the states of one fixed step in place of exact time evolution. The step, its order and r define the trial space, so changing them changes the basis, and none of them is an accuracy setting. A projected Ritz value does not certify the full-space ground energy.

V is built once, and its emitted angles are saved with the Plan. With the default evolution="pauli_terms" its factors are the nonidentity Pauli terms of A0 in the Plan's label order. Each factor is the rotation exp(-i theta P/2): order 1 applies every term for the substep dt = time_step/r, with theta = 2 c dt for the coefficient c, and order 2 applies every term for dt/2 and then every term again in reverse order, with theta = c dt. The identity term contributes only a global phase and is left out of V, and the solve adds c_I back to the Ritz values.

With evolution="fermionic_blocks" V comes instead from an explicit fermionic generator B = c_B I + B0 in evolution_terms, while H, S and the energies remain those of A. B is split into complete Hermitian blocks, one for the real and one for the imaginary part of each pair of adjoint ladder terms, or one for a self-adjoint term. The blocks are number, hopping, density, hopping times a spectator number, and double-excitation terms. A block maps under Jordan-Wigner to commuting Pauli words, so the rotations of its words give its exponential exactly. Order 1 applies every block once, and order 2 applies every block for half the substep and then every block again in reverse order. Each block conserves the particle number, and V applies the exponential of every block whole, never split or interleaved with another, so V conserves it as well. A product formula of the Pauli terms of A in their label order need not conserve it even when A does. The constant c_B is left out of V and never enters an energy, so a B without nonidentity terms gives V = I and a basis of copies of psi. The Plan's assumptions state the upper bounds delta_gen_0 = sum_{P != I} |a_P - b_P| on ||A0 - B0|| and delta_gen_full = |c_I - c_B| + delta_gen_0 on ||A - B||, which do not bound the distance of V from exp(-i tau A0), and they state whether the basis lies in the particle-number sector of the reference. That needs an occupation reference or a product of computational basis states. With exact H and S, the Ritz value is then a Rayleigh-quotient value of A on a state of that sector, and so an upper bound on the smallest eigenvalue of A and, when A itself conserves the particle number, which QFD does not check, on the smallest eigenvalue of A in that sector. Spin projection and total spin are not qualified, since evolution_terms has no spin labels.

Quantum execution only. A pair i < j prepares the joint state (|0>|phi_i> + |1>|phi_j>)/sqrt(2) of one ancilla and the system. With the default pair_preparation="prefix" of acquisition, the end of smaller absolute power b (the smaller index on a tie) runs the reference and V**b once without control, and the remaining power difference is controlled on the ancilla, so only the difference costs controlled steps. With "controlled" both complete preparations are controlled. With shots=None (exact readout) every pair is reduced to H0_ij and S_ij from its simulated state. With shots=n each pair and each of the G qubit-wise commuting groups of terms is one setting, off-diagonal pairs in both the X and Y ancilla bases, so a basis of M powers has M**2 G settings and n M**2 G shots. The quadratures are always complex, even for a real A, because the time-evolved states are complex in general. With sampling=PencilSampling(...) in place of shots=, the same settings are measured in a uniform pilot stage and again in a main stage whose shots per setting the pilot pencil decides, and only the main-stage measurements form H, S and the reference energy. A setting stops the run when its circuit fails max_native_two_qubit_depth, with the earlier settings' counts kept. overlap_cutoff can be changed after the run with result.analyze(overlap_cutoff=...), which reuses the same matrix elements.

Attributes:

  • initial_state (StateData) –

    Required. The reference state psi, in a form that StateData accepts, prepared with its phase once per circuit, except an off-diagonal pair under pair_preparation="controlled", which prepares it under control on both ancilla branches. An occupation or product state keeps planning compact on many qubits.

  • time_step (Real) –

    Required, finite and positive. The time step tau of V in inverse units of the Hamiltonian's energy (with hbar = 1), for example 1/Hartree for a Hamiltonian in Hartree.

  • powers (tuple[StrictInt, ...]) –

    Required. Distinct integers including 0, the powers of V in basis order. Their order is the order of the rows and columns of H and S, and 0 need not come first.

  • steps_per_time_step (PositiveInt) –

    Default 1. The number r of product-formula substeps of V, fixed for every power.

  • formula_order (Literal[1, 2]) –

    Default 2. Product-formula order of each substep, 1 or 2.

  • evolution (Literal['pauli_terms', 'fermionic_blocks']) –

    Default "pauli_terms", the product formula of the Pauli terms of A above. "fermionic_blocks" builds V from the complete fermionic blocks of evolution_terms.

  • evolution_terms (OperatorData | None) –

    Default None. Required with evolution="fermionic_blocks" and None otherwise: the generator B as a fermionic OperatorInput from ingest_fermion or chemistry_evolution_terms. Its coefficients are read in the energy unit of A. Mode j acts on qubit j of A, with |1> occupied, so B has as many modes as A has qubits. Each row is a scalar, a_p^dagger a_q or a_p^dagger a_q^dagger a_r a_s, written with its creations left of its annihilations, and B must be exactly Hermitian: after normal ordering the coefficients of each term and of its adjoint are exact complex conjugates, and that of a self-adjoint term is real. Planning refuses other operators. Its content hash is part of the Method's.

  • evolution_diagnostics (QFDEvolutionDiagnostics | None) –

    Default None. The QFDEvolutionDiagnostics that chemistry_evolution_terms returned with evolution_terms, saved with the Method. It requires evolution="fermionic_blocks", and its evolution_input must equal the content hash of evolution_terms. A generator from another source needs none.

  • overlap_cutoff (Real) –

    Default 1e-12, positive. Overlap eigenvectors with eigenvalues above it are kept for the solve.

  • max_basis_size (PositiveInt) –

    Default 64. Largest accepted number of powers.

  • max_experiments (PositiveInt) –

    Default 100_000. Largest number of settings: exact pair reductions, or sampled group settings.

  • max_bytes (PositiveInt) –

    Default 10 GB (decimal, 10_000_000_000 bytes). Limit on the known bytes of conversion, the pair table, the grouped count analysis and the projected solve, and on each exact pair reduction's workspace.

  • max_analysis_work (PositiveInt) –

    Default 1_000_000_000. Limit on the work of the projected solve, of the comparisons that form qubit-wise commuting groups and of each pass of the grouped count analysis, checked at planning for one measurement per setting and again before the stored counts are decoded.

  • max_classical_products (PositiveInt) –

    Default 100_000_000. Limit on the summed classical work of the exact pair reductions.

  • input_conversion (Literal['auto', 'dense_pauli']) –

    Default "auto", which keeps Pauli input as it is and converts an explicit dense matrix of dimension at most 16 to Pauli form. "dense_pauli" also permits the conversion of sparse matrices and of larger dense matrices, within max_conversion_work and max_bytes.

  • max_conversion_work (PositiveInt) –

    Default 100_000_000. Limit on the counted work of operator-to-Pauli conversion.

  • max_admission_steps (PositiveInt) –

    Default 10_000_000. Limit on the planning work of checking each Program that the method builds (planning work limit), on the number of uses of V in all its circuits, checked before the circuits are described, and on the circuit instructions of the distinct evolution blocks that the Plan uses (V, its adjoint and their controlled forms), each r times the instructions of one substep, checked at planning before any block is built. Each of the three counts is compared with the limit separately.

  • acquisition (PencilAcquisition) –

    Default PencilAcquisition(). QFD measures grouped joint states, so matrix_measurement must be "grouped", and pair_preparation is "prefix" or "controlled". ADAPT's "vacuum_reference" and "vacuum_restore" need a known vacuum phase, and QFD records and computes none for V, so planning raises ApplicabilityError for either value whenever the Plan measures anything, that is, for every A that is not a multiple of the identity, powers=(0,) included, with exact readout and with shots alike. For a multiple of the identity the request is kept unused, with resolved pair_preparation None, and no circuit runs. A Plan with shots measures complex quadratures and rejects quadratures="real" at planning. With exact readout, which measures no quadratures, the requested value has no effect and is recorded as None. The Plan records the resolved choices, with the construction of every pair, in plan.reconstruction.pencil.acquisition.

  • max_native_two_qubit_depth (Count | None) –

    Default None, which requests no depth limit. A nonnegative integer D requires each submitted circuit, every grouped count setting and every exact pair reduction, to have a native two-qubit depth of at most D, with D itself allowed. The depth is that of the circuit the backend prepared for execution, with the reference preparation, the uncontrolled and controlled powers of V, the measurement basis changes and the backend's qubit routing. Each circuit is checked just before its submission, and one whose depth exceeds D or is unavailable is not submitted: the run raises nwqlib.backends.inspection.NativeDepthCapRefusal. Settings submitted earlier keep their counts and shots in the Run. The limit changes no circuit, power or term. Only IBM Runtime computes this depth, under the conditions that FixedGCIM describes for the same field. Under sampling it applies to every pilot and main circuit.

  • sampling (PencilSampling | None) –

    Default None, which measures every setting with the shots= of the call. A PencilSampling replaces shots= with a pilot stage and a main stage whose shots per setting the pilot decides, as for FixedGCIM. The Result's shot_allocation records that decision. nwqlib.estimate(plan) then reports the totals of the whole Plan, such as its settings and shots, as unavailable, because each setting is measured in a pilot stage and again in a main stage whose shots the pilot decides. One prepared setting, whose stage and shots are fixed, is estimated normally from its preparation record. The shot budget of a Run is PencilSampling.total_shots.

Raises:

  • ValueError –

    If acquisition requests termwise measurement, if evolution_terms is missing with "fermionic_blocks", set with "pauli_terms" or not fermionic, or if evolution_diagnostics does not belong to evolution_terms on that route.

Examples:

For A = -Z on one qubit, psi = (|0> + |1>)/sqrt(2), a time step of 0.5 and the powers 0 and 1, the two basis states span the qubit, so on Aer with exact readout the lowest Ritz value is the ground energy -1 up to rounding, which lies 1 below the reference energy 0:

>>> from nwqlib import Eigenproblem, solve
>>> from nwqlib.algorithms import QFD
>>> from nwqlib.operators import ingest_pauli
>>> from nwqlib.problems import ingest_product
>>> A = ingest_pauli((("Z", -1.0),), num_qubits=1)
>>> psi = ingest_product([[2**-0.5, 2**-0.5]])
>>> result = solve(Eigenproblem(A=A), method=QFD(initial_state=psi, time_step=0.5, powers=(0, 1)),
...                seed=7)
>>> print(round(result.eigenvalue, 10), round(result.lowering, 10))
-1.0 1.0

With the fermionic generator B = 5 + n_0, where n_0 = a_0^dagger a_0 = (I - Z)/2, V rotates the same psi about Z, and the two basis states again span the qubit. H and S belong to A = 3 I + X, so the lowest Ritz value is its ground energy 2 and the reference energy is <psi|A|psi> = 4. The constant 5 of B enters neither V nor an energy:

>>> from nwqlib.operators import ingest_fermion
>>> A = ingest_pauli((("I", 3.0), ("X", 1.0)), num_qubits=1)
>>> B = ingest_fermion([(5.0, []), (1.0, [(0, 1), (0, 0)])], num_modes=1)
>>> method = QFD(initial_state=psi, time_step=2.5, powers=(0, 1), evolution="fermionic_blocks",
...              evolution_terms=B)
>>> result = solve(Eigenproblem(A=A), method=method, seed=7)
>>> print(round(result.eigenvalue, 10), round(result.reference_energy, 10))
2.0 4.0

QFDResult

Bases: Result

Lowest Ritz energy from a QFD run, with the reference energy and the projected matrices.

solve returns it for a QFD method, and load_result reopens a saved one. eigenvalue is the lowest kept Ritz value of the projected pencil H f = E S f of the basis V**p_j |psi>, in the unit of the Eigenproblem. reference_energy is H[i0, i0] = <psi|A|psi> of the reference, at the basis index i0 of the power 0, which need not be the first index. lowering is reference_energy - eigenvalue, negative values included. With exact, consistent H and S the Ritz value is at most the reference energy when no overlap direction is cut, and at least the smallest eigenvalue of A, but sampled matrices carry neither guarantee. The value is a projected estimate in the chosen trial space, not a certified ground energy, and a lowering is not a recovered fraction of a correlation energy. pencil holds H, S and the solve diagnostics: kept rank, the complete overlap spectrum and the condition number of the kept directions. print(result) shows the values, the basis schedule and the scope, and result.analyze(overlap_cutoff=...) solves the same matrix elements at another cutoff without new measurement. The fields of Result are present too.

Attributes:

  • eigenvalue (Real | None) –

    Lowest kept Ritz value in the problem's energy unit, or None when data are missing or the solver rejected the pencil.

  • reference_energy (Real | None) –

    H[i0, i0], the energy of the reference state in the same unit, from the same pencil, or None without a pencil. For an operator that is a multiple c I of the identity it is c, as is eigenvalue.

  • lowering (Real | None) –

    reference_energy - eigenvalue, or None when either is None. It is not clipped at zero.

  • missing (tuple[Text, ...]) –

    Names of planned measurements with no returned data. A nonempty tuple means no pencil was solved.

  • pairs (tuple[PairEstimate, ...]) –

    Exact pair measurements: pooled H0_ij and S_ij with their reductions and entry error bounds. Empty for sampled Plans.

  • estimates (tuple[ScalarEstimate, ...]) –

    For a sampled Plan, the pooled weighted group means (ScalarEstimate).

  • group_moments (tuple[GroupMoment, ...]) –

    For a sampled Plan, the moments of every count measurement, in measurement order.

  • sampled_pair_variances (tuple[SampledPairVariance, ...]) –

    For a complete sampled pencil, the pooled sample-mean variances and overlap–H0 covariance of each pair.

  • pencil (ProjectedPencil | None) –

    The ProjectedPencil in basis order, or None for partial data or when the operator is a multiple of the identity, which needs no H or S. Under PencilSampling it is formed from the main-stage measurements only, and so is reference_energy.

  • analysis_cutoff (Real) –

    Overlap-eigenvalue cutoff used by this analysis.

  • target_identification (Text) –

    Fixed statement of what the value does not establish.

  • shot_allocation (ShotAllocation | None) –

    Under PencilSampling, the pilot decision (ShotAllocation) as it was decided, or None before it. Then estimates, group_moments, sampled_pair_variances, pencil, missing and contribution_ids concern the main stage only, and a Result from before the decision lists every setting in missing. The pilot measurements stay in the Run's observations. None without PencilSampling.

QFDReconstruction

Bases: Record

The fixed step V and the Pauli tables that turn the observations of a QFD Plan back into H and S.

plan.reconstruction of a QFD Plan holds it. V applies, for each of its r substeps, the rotations R_P(theta) = exp(-i theta P/2) of the rows step_rows of evolution_rows with the angles step_angles, in this order. Basis state j is V repeated powers[j] times, or its adjoint repeated -powers[j] times, applied to the reference. With QFD.evolution="pauli_terms" the rotations come from the Pauli table of the target in pencil. With "fermionic_blocks" they come from the generator B of QFD.evolution_terms, whose table is evolution, and step_blocks marks its complete blocks. H and S always belong to the target in pencil.

Attributes:

  • schema_version (Literal[1]) –

    Record layout version.

  • pencil (FixedGCIMReconstruction) –

    The Pauli table of the target A, basis size, groups and measurement choices shared with FixedGCIM (FixedGCIMReconstruction). Its acquisition.pairs records the construction of every off-diagonal pair.

  • substep (Real) –

    The emitted binary64 substep time_step/steps_per_time_step in inverse energy units.

  • step_rows (FrozenArray) –

    int64 array of the positions in evolution_rows of the factors of one substep, in execution order. Empty when the generator of V is a multiple of the identity, which makes V the identity.

  • step_angles (FrozenArray) –

    float64 array of the emitted angle theta of each factor.

  • reference_index (Count) –

    Basis index of the power 0, the reference state.

  • evolution (PauliArrays | None) –

    None for "pauli_terms". For "fermionic_blocks", the Pauli table of B (PauliArrays): one row for each distinct word that a factor of V uses, with the coefficient of B summed over its blocks and rounded once, and the identity row, whose coefficient is c_B. A word whose coefficients cancel keeps its row with coefficient 0. The coefficients describe B. V uses only the words and step_angles.

  • step_blocks (FrozenArray | None) –

    None for "pauli_terms". For "fermionic_blocks", the int64 positions in step_rows where each complete block of one substep starts, strictly increasing from 0, and empty when V has no factors. A block runs to the next start or to the end of the substep.

evolution_rows 

evolution_rows

The nonidentity (label, coefficient) rows that step_rows index: those of pencil, or of evolution when it is set.

Evolve with a generator from chemistry integrals

With evolution="fermionic_blocks", QFD builds V from an explicit fermionic generator B, one complete number-conserving Hermitian block of ladder terms at a time, so every basis state from an occupation reference keeps its particle number. H, S and the energies remain those of A. chemistry_evolution_terms takes the data from build_gcim_chemistry_problem and returns B, built from its integrals, with a QFDEvolutionDiagnostics record of how B was derived. Passed to QFD as evolution_diagnostics, the record is saved with the Method. B and the Hamiltonian A of the same data can differ, and the Plan states upper bounds on their distance.

chemistry_evolution_terms 

chemistry_evolution_terms(data, evolution_coefficient_cutoff=0.0)

Return a Hermitian fermionic evolution generator B for QFD from the integrals of chemistry data, with its diagnostics.

Pass both results to QFD: terms, diagnostics = chemistry_evolution_terms(data) and then QFD(initial_state=..., time_step=..., powers=..., evolution="fermionic_blocks", evolution_terms=terms, evolution_diagnostics=diagnostics), with the target data.eigenproblem() and, for example, ingest_occupation(data.reference_occupations, num_qubits=data.num_qubits) as the reference. The helper reads the spatial one-body array h, the two-body array v[p,q,r,s] = (ps|qr), constant_energy E_c, the "name" and "integral_convention" entries of metadata and reference_occupations. It runs no electronic-structure calculation, and it changes neither data, its arrays nor data.hamiltonian, which remains the target A. B differs from A in general, and the Plan states upper bounds on their distance.

Raw table. Spin modes are interleaved, mode 2p + sigma for spatial orbital p with alpha sigma = 0 and beta sigma = 1. The integrals are expanded to spin orbitals by the same routine as build_gcim_chemistry_problem, and every nonzero entry gives one term of E_c + sum h_ab a_a^dagger a_b + 1/2 sum v_abcd a_a^dagger a_b^dagger a_c a_d, the factor 1/2 applied once as one binary64 product. The terms are normal ordered with exact anticommutation signs and equal monomials summed, removing only exact zeros. The resulting coefficients g_T of the normal-ordered monomials T define the table C_raw, which need not be Hermitian because binary64 integrals need not be exactly symmetric. C_raw holds these binary64 values and is not an exact conversion of the integrals.

Projection. For a pair of distinct adjoint monomials, T^dagger = s_T T_bar, where s_T = +1 for every monomial of this domain, the returned coefficients are b_T = m_T and b_bar = s_T m_T with

m_T = RN((val(g_T) + s_T val(g_bar)) / 2),

the exact midpoint rounded once, which is the coefficient of the Hermitian part (C_raw + C_raw^dagger)/2 in exact arithmetic. For two values x and y, (z - x)**2 + (z - y)**2 is smallest at the midpoint, so this is the least-squares symmetric correction of the pair of C_raw, which says nothing about the exact integrals. For the one-body part it gives h_B[p,p] = h[p,p] and h_B[p,q] = h_B[q,p] = RN((h[p,q] + h[q,p])/2). A self-adjoint monomial keeps its real coefficient and E_c is kept. B is then exactly Hermitian, as QFD requires of evolution_terms.

Cutoff. After the projection a pair with |m_T| <= gamma is removed on both sides, a self-adjoint monomial with |b_T| <= gamma is removed, and E_c is never removed. gamma = 0 removes only exact zeros. Removing a number or density term changes the identity coefficient c_B of B and never the target's.

Parameters:

  • data (GCIMChemistryProblemData) –

    The chemistry data, for example from build_gcim_chemistry_problem, with real finite integrals in Hartree.

  • evolution_coefficient_cutoff (float, default: 0.0 ) –

    Default 0.0. The cutoff gamma in Hartree, finite and at least 0, compared with the projected coefficients, which include the factor 1/2.

Returns:

  • terms ( OperatorInput ) –

    B as a fermionic input from ingest_fermion, one row per kept monomial, on data.num_qubits modes.

  • diagnostics ( QFDEvolutionDiagnostics ) –

    The source of B, the cutoff, the counts of changed and removed pairs, upper bounds on the corrections, the one-body asymmetry of h, c_B and the spin statement of the blocks.

Raises:

  • ValueError –

    If the cutoff is negative, nonfinite or not a number, if an integral is nonfinite or has a nonzero imaginary part, or if the mode count or the reference occupations do not match the interleaved spin orbitals.

Examples:

For H2 in STO-3G (requires pyscf and openfermion):

>>> from nwqlib.algorithms.gcim import build_gcim_chemistry_problem
>>> from nwqlib.algorithms.qfd import chemistry_evolution_terms
>>> data = build_gcim_chemistry_problem("H 0 0 0; H 0 0 0.74", basis="sto-3g", reference_methods=())
>>> terms, diagnostics = chemistry_evolution_terms(data)
>>> print(terms.basis.dimension, diagnostics.dropped_pairs, diagnostics.evolution_coefficient_cutoff)
16 0 0.0

QFDEvolutionDiagnostics

Bases: Record

How chemistry_evolution_terms derived a fermionic evolution generator B from the integrals of chemistry data.

chemistry_evolution_terms returns it with B. Pass both to QFD, as QFD(..., evolution="fermionic_blocks", evolution_terms=terms, evolution_diagnostics=diagnostics), and the record is saved with the Method, the Plan and the Result, where result.plan.method.evolution_diagnostics reads it. QFD requires evolution_input to equal the content hash of its evolution_terms.

The helper builds the table C_raw of the integrals, with one coefficient g_T per normal-ordered ladder monomial T, and returns B = sum_T b^gamma_T T after one Hermitian projection and a cutoff gamma. C_raw is the operator of that table, formed from the binary64 integrals with the factor 1/2 of the two-body terms and the summation of equal monomials, and may be non-Hermitian. With q the unrounded Hermitian table, b the projected table before the cutoff and b^gamma the returned table, summed over every monomial, the two sides of a pair counted separately,

||B - C_raw|| <= sum_T |b^gamma_T - g_T| <= Delta_sym + Delta_round + Delta_drop,

since every nonzero normal-ordered monomial has norm at most 1, with Delta_sym = sum_T |q_T - g_T|, Delta_round = sum_T |b_T - q_T| and Delta_drop the sum of |b_T| over the dropped monomials. Every bound below is computed in exact rationals from the binary64 values and rounded up once, and it is None when it overflows binary64. These bounds compare B with the table C_raw of the integrals. They do not bound the evolution, since C_raw need not be Hermitian, and neither they nor the one-body correction measures the accuracy of a molecular energy. Upper bounds on the distance between the target A and B are stated in the Plan's assumptions. The fields below are read-only.

Attributes:

  • schema_version (Literal[1]) –

    Record layout version.

  • evolution_input (ContentID) –

    Content hash (reference.identity) of the B that the helper returned.

  • source_name (Text | None) –

    The "name" entry of the chemistry data's metadata, or None when it has none.

  • integral_convention (Text | None) –

    The "integral_convention" entry of that metadata, or None.

  • one_body_shape (tuple[Count, Count]) –

    Shape of the spatial-orbital one-body array.

  • two_body_shape (tuple[Count, Count, Count, Count]) –

    Shape of the spatial-orbital two-body array.

  • transformation (Literal['signed midpoint of each pair of adjoint canonical monomials, rounded once, then removal of whole pairs at or below the cutoff']) –

    Fixed name of the projection and cutoff.

  • domain (Literal['real finite spatial-orbital integrals h[p,q] and v[p,q,r,s] = (ps|qr), spin modes 2p + sigma with alpha sigma = 0 and beta sigma = 1']) –

    Fixed statement of the inputs and mode order the helper accepts.

  • evolution_coefficient_cutoff (Nonnegative) –

    The cutoff gamma in Hartree, at least 0.

  • changed_pairs (Count) –

    Number of pairs of distinct adjoint monomials whose projected coefficients differ from those of C_raw.

  • dropped_pairs (Count) –

    Number of pairs of distinct adjoint monomials, and of self-adjoint monomials, that the cutoff removed.

  • symmetrization_correction (Nonnegative | None) –

    Upper bound on Delta_sym.

  • rounding_correction (Nonnegative | None) –

    Upper bound on Delta_round.

  • dropped_mass (Nonnegative | None) –

    Upper bound on Delta_drop.

  • raw_difference (Nonnegative | None) –

    Upper bound on sum_T |b^gamma_T - g_T|, and hence on ||B - C_raw||.

  • max_one_body_asymmetry (Nonnegative | None) –

    Upper bound on max_{p<q} |h_pq - h_qp| of the spatial one-body array h of the data.

  • one_body_correction (Nonnegative | None) –

    Upper bound on sum_pq |dh_pq|, with dh = h_B - h and h_B the spatial one-body coefficients of the returned B.

  • one_body_correction_bound (Nonnegative | None) –

    Upper bound on 2 sum_pq |dh_pq|, which bounds the norm of the one-body correction sum_pq,sigma dh_pq a_{p sigma}^dagger a_{q sigma} on the Fock space, the factor 2 for the two spin blocks.

  • generator_shift (Real) –

    The identity coefficient c_B of the Jordan-Wigner image of B, rounded once. It is not added to any energy.

  • spin_statement (Text) –

    How many pairs of adjoint monomials and self-adjoint monomials of B conserve the alpha and beta electron numbers, and so Sz, under the mode order 2p + sigma, with the particle number and Sz of the reference occupations.

  • scope (Literal['the bounds compare B with the table C_raw of the integrals, which need not be Hermitian, so they do not bound the evolution, and they do not measure the accuracy of a molecular energy']) –

    Fixed statement of what the bounds above compare.

solve calls plan and the other hooks of a Method. Extending NWQLib describes them.