Limitations and open work

This page lists what each method can do now, what has been checked, the known limits and the open work. The guides for LCHS, QPE, QLS, GCiM and QHD give the details of each method.

Current capabilities

Every method follows one workflow: a Problem and a Method give a Plan, from which NWQLib estimates resources, runs the circuits as a Run and attaches the Result, and saved data is loaded only on request. The analytical test fixture supplies fixed analytical test values for that workflow and its accounting. It does not establish general method or backend support.

Area	What it does	What has been checked
Finite Pauli expectation	Exact readout by group, or sampled readout without error mitigation that measures the whole register once per qubit-wise commuting group. Binary readout calibration uses parity shots. Point estimates, variances and fixed-time, time-uniform and Beta intervals stay separate quantities.	Small cases against independently computed scalars and injected test data. Shared calibration covariance stays explicit. An interval uses only a chronological prefix of complete sets of fresh shots, so data that omit an earlier set or keep a chosen subset leave it unavailable (Accumulated and imported data). The statistical premises and the transfer through the readout channel do not certify complete physical accuracy.
Chebyshev Lanczos	Configurable initial state and Krylov dimension, a shared signed-walk Plan, exact marginals or counts, resource totals of the planned construction, an explicit two-stage sensitivity analysis and a classical recurrence.	Small cases against independent algebra, and checks of the Chebyshev chain that actually ran. Projected values keep the original target, the smallest eigenvalue, and leave the ground-identification and native error sources unknown. The finite basis, the empirical shot allocation and the cutoff do not certify physical energy accuracy.
LCHS	Time-independent homogeneous and constant-source inhomogeneous workflows. Classical and quantum Methods with explicit verification, finite scalar refinement, coefficient MPS analysis and resource operations. Dense, product-formula and compiled-QSP evolution.	Small dense references, independent product-formula references, agreement of circuits with theory, and the saved scientific examples.
QPE	QCELS, SPE, RFE and adaptive RWPE share one planning and execution workflow, and coherent QPE is separate. Controlled powers of dense unitary or Hermitian matrices and of real PauliSum Hamiltonians.	Tiny cases against analytic values, injected data and native circuits, tracing of each reported scalar to the observations it came from, explicit checks of the nominal eigenvalue cluster, and reopening of saved RWPE runs. Local intervals do not establish a complete accuracy claim.
GCiM	FixedGCIM and explicit ADAPT on shared planning, execution and report code, with several operator pools, optional reoptimization and verification. Chemistry inputs, which need the optional chemistry packages, and conversion of a supplied real double-factorized (DF) Hamiltonian feed the existing Jordan–Wigner energy evaluation.	Small cases against independent matrices, gradients and native circuits. Sampled and exact pencils stay distinct, and saved runs keep the current basis apart from its history. Chemistry and larger trajectories keep their separately recorded scope.
QLS	Three solvers, the polynomial inverse and two shortcuts, with support for the structured periodic family, shared classical and quantum execution, and explicit resource and verification operations.	Small cases against independent numerical results and native circuits, with each physical output tied to its source. Assistance, conditioning and unsupported capabilities are stated explicitly.
QHD	One-hot construction on a Dirichlet or periodic grid, or binary construction on a periodic grid, with compact native kernels and bounded classical evolution on the host. Quadratic, cubic and shifted-cubic schedule records with midpoint or integrated coefficients, uniform, kinetic-ground and Gaussian initial states, classical Schrodinger, IR-product and split-step flavors, candidate and most-probable readout with conditional position statistics, and explicit verification. Rotation counting formulas, budgeted T estimates and separate per-circuit error sources for one circuit, with rotation and T totals over an augmented-Lagrangian run or a refinement. The augmented-Lagrangian layer solves a ConstrainedOptimization by a sequence of QHD Plans and has an explicit evaluated finite-grid reference. Box refinement repeats QHD on shrinking boxes in a physical or dimensionless search model, with an optional stall split. Both layers can save their state in a directory. Resuming reopens the recorded inner Run with its recorded Plan and run log. A recoverable Run can continue, including a remote result that becomes available after an interruption. Some interrupted local preparation, data collection or classical evolution cannot be completed from the saved Run.	Small cases against independent grid, action and outcome-distribution values, grid minimization as the reference for the augmented-Lagrangian trajectories, and independent interval, box and invariance checks for refinement. With the default trotter_order=2 and rotation_threshold=0, which drops no rotation, the one-hot circuit's probabilities approach those of the finite model at second order in the step length, in a small periodic case with a constant Hamiltonian (Scientific model and ordering, Proposition 40). This convergence is distinct from discretization, floating-point error and global optimality. Stopping statuses and refined points describe finite-grid searches, not continuous or global optima.
Shared subroutines	State preparation, LCU, block encodings, Hamiltonian evolution, QSP and QSVT, QPE primitives, resource records, reporting, validation, and the interfaces to local and cloud backends.	Unitary and statevector tests, independent numerical references, mutation tests of scientific formulas, and mocked providers in CI.
Saved data and public workflows	Typed verification records and certificates, size-limited saved metadata and loading of the binary arrays a Plan uses, explicit reanalysis, method cards and configuration schemas, the CLI, and populated conformance checks for Method authors.	Loading a saved Source imports and runs nothing, a missing array stays unavailable, and reanalysis runs no new measurement. Checks of an installed package establish only the package and runtime combination they ran on and the behavior of records in the current format.

The top-level nwqlib package exposes the common workflow and search functions and its modules, and imports each module on first use. Methods and records are imported from their own packages, and the API reference documents the exports.

Limitations

Chebyshev Lanczos

• The Lanczos guide documents the one method, chebyshev_lanczos. Its signed Pauli encoding does not require THC factorization. It is not a THC-BLISS implementation or a claim of minimum hardware cost.
• Exact and counts-based quantum execution and classical execution each have their own numerical and circuit limits. ExecutionLimits bounds the simulator width and the stored data, and raising those limits does not make execution scalable.
• Pilot allocation, overlap regularization, and projected numerical diagnostics are empirical choices. Final main-stage moments exclude pilot data. Nonlinear Ritz energies have no finite-budget unbiasedness or physical-accuracy certificate.
• XACC preserves literal ordered products with at most four ladder operators per term. Reference occupations, electron sector, spin ordering, and units are explicit metadata, never inferred chemistry conventions.
• Counts readout adds a label-controlled basis transform for odd-degree moment settings. Fewer measurement settings do not establish lower compiled gate cost or improved hardware accuracy. Broader encodings, certified adaptive statistics, and Hamiltonian-specific factorization improvements require a concrete workload and independent evidence.

LCHS

• Time-dependent LCHS workflows remain deferred. The public workflows and shared term construction currently implement time-independent homogeneous systems and time-independent systems with a constant source term.
• Dense input and dense-exact SELECT provide explicit finite realizations, not scalable oracle models. Product-formula and compiled-QSP (qsp_block_encoding) choices expose more structured circuit paths, but end-to-end scale is still limited by simulation and synthesis. Scalable LCHS SELECT describes the planned work.
• The general dense-input compiled-QSP route derives its Pauli and block-encoding decomposition from that input. Structured families chosen separately use their documented access and error formulas. Neither route establishes an arbitrary sparse-input oracle.

QPE

• By default a dense target uses an explicit dense power circuit, and a real PauliSum Hamiltonian uses compact product-formula powers directly. The classical route remains a bounded nominal-overlap model. Arbitrary unitary targets do not acquire a scalable power oracle.
• Estimator confidence statements are method-specific. They should not be compared as if all methods returned the same statistical object.
• Broad performance benchmarking across hardware providers is outside the current validation suite.

GCiM

• Chemistry input requires the optional chemistry dependency set and remains guarded when those packages are unavailable.
• FixedGCIM publishes projected matrices and numerical diagnostics, but its default total-error assessment has no automatic producer of the required physical-output error bounds. See GCiM physical-output error bounds and automatic assessment for the open work and the guide for quantities available now.
• A FixedGCIM Plan can pass its planning checks while its resource estimate exceeds the work limit of the resource total. See GCiM resource estimates for many settings for an open-chain example that did so before grouped readout.
• Adaptive pool growth and optimizer behavior are research choices rather than universal convergence guarantees.
• Circuit-level validation is limited to small active spaces. Larger chemistry studies require an external resource and accuracy assessment.
• Exact quantum ADAPT execution reads Pauli values from the backend, execution with shots measures the planned groups, and classical execution evaluates its queries on the host. The three paths share one projected solver and keep sampled values distinct from exact algebraic ones.
• The ADAPT iteration state keeps the completed basis and its history apart from the current analysis throughout a Run. Reopened scalar results need no rebuilt pencil for reporting or scalar comparison, while state verification needs the current pencil and the planned data access. A noisy enclosure diagnostic is distinct from a refusal by the solver.

QLS

• Oracle-first structured inputs do not support every automatic norm or condition-number strategy. Unsupported combinations fail explicitly.
• Analytical resource formulas describe their planned constructions and declared domains. They are not optimized hardware counts.
• Polynomial fits and shortcut constructions remain sensitive to the supplied spectral interval and error budget.

QHD

• The QHD core solves a supplied bounded objective using the one-hot encoding with a Dirichlet or periodic finite-difference kinetic term, or the binary encoding with a periodic finite-difference or spectral kinetic term applied through the QFT. The one-hot periodic grid needs an even number of points of at least 4, a limit of the one-hot link compiler rather than of the periodic Laplacian. The classical split-step flavor applies the kinetic term in its eigenbasis and also offers the periodic spectral kinetic term for the one-hot model.
• The binary encoding supports the periodic grid only. A Dirichlet binary kinetic term needs a sine-transform circuit. Its diagonal syntheses are chosen table by table, and parity-network synthesis that shares CX between Walsh strings is not implemented. Its structured preparation prepares the uniform state only, and other initial states use Qiskit's state preparation.
• Statevector and shot validation is limited to small grids. The classical route evaluates the planned finite model. It is not evidence of scalable circuit execution.
• The augmented-Lagrangian layer and box refinement search the finite grid of each box, except that the mode_or_mean point rule can read an off-grid mean position. The default stopping status feasible_complementary does not include the projected stationarity of Birgin and Martinez, doi:10.1137/1.9781611973365, Eq. (10.6), so it is not convergence and does not assess optimality. Finite-grid multipliers are dual iterates of the grid problem, not continuous KKT multipliers. A problem with equality constraints must set feasibility_tolerance, because the residual a grid can reach depends on the grid, and when no grid point satisfies an equality within that tolerance, no penalty value lets a grid point pass the feasibility test.
• Constraint and objective scales default to 1, which assumes a dimensionless problem. The layer does not estimate them, and an unscaled constraint factor of 1000 multiplies the quadratic penalty by 10**6. A larger penalty can increase the range of the augmented objective and, on the Schrodinger path, increase its generator-norm charge. The range need not grow monotonically because the objective, linear multiplier term and quadratic penalty can cancel. A round after the first that the planning checks refuse ends the run with inner_failed, while a refused first round raises its original error.
• BoxRefinement defaults to the search model with potential gain 8, chosen from a two-variable comparison of the physical model with gains 1 and 8 of the search model, so no gain is established as best in general. The step count must resolve both the kinetic and potential evolution. A larger gain can increase potential phases and product-formula error, so the default gain does not establish that a chosen step count is adequate. The gain-8 convergence evidence uses classical Schrodinger evolution. For a circuit-product comparison, also check the product approximation and the numerical-reference limitations of ir_product. The search model solves a different dimensionless Hamiltonian at each level and makes no claim about the dynamics of the original QHD Hamiltonian. stall_split="best_region" discards the probability of one region on the evidence of two objective values, so it is not the default. With a positive split budget it refuses a periodic grid, because one cut opens a periodic axis but does not divide it into two regions.
• The Schrodinger and split-step flavors need different step counts for the same final-state error. In the measured comparison the split-step flavor reached each error target with less work and wall time than the Schrodinger flavor, by a factor that depended on the grid, the target and the penalty, so no general rule selects the cheaper flavor for a new problem.
• Runs of the problems of Wu et al., arXiv:2605.12066v1, and Liu et al., arXiv:2607.16996v1, use NWQLib's numerical choices and are cross-checks of those papers, not reproductions of their computations. Explicit comparison settings with ShiftedCubicSchedule(s=1), the form that Liu et al.'s code runs as qhd-c, reproduce the binary CX and Rz counts of their Table II, whose caption names QHD-C, which their Eq. (92) defines as the cubic schedule (circuit synthesis). The optimization tables of Wu et al. and the dynamics figures of Liu et al. are not reproduced. Wu et al.'s results used a left-endpoint time rule, level rescaling rules and left-endpoint boxes that NWQLib does not offer, because the time rule is first order, the boxes are shifted by half a cell and the rescaling couples the potential gain to an evolution speed that depends on the coordinate units. The arrays and the executed schedule behind Liu et al.'s figures are not available.
• The size and work counts that planning checks for an objective miss some expansions and evaluations (QHD objective expansion check).

Cross-cutting

• Dense simulation is used deliberately as an independent validation layer in several algorithms. A successful dense run is not a scalability claim.
• Cloud backends use the common checked path for preparation, submission, refresh and observation. Checks with the public SDKs and injected responses cover the documented mappings of counts and estimates. Live credentials, queues, compilation and hardware have not been qualified. See backends, IonQ and Nexus.
• Resource estimates identify their basis, precision, the set of circuits and shots they count, and their model scope. Analytical, representative and observed native counts must not be treated as interchangeable.
• The resource total of a Plan describes the workload the Plan represents, while preparation and execution keep their own records of preparations and events. Resource operations do not submit jobs or turn unknown native costs into zero.
• Stored reference outputs and example checks protect recorded behavior and complement independent numerical tests without replacing them.

Open work

Scalable LCHS SELECT

This item has high priority, because the default quantum route limits LCHS to small systems. That route, dense_exact, computes each branch exponential classically and synthesizes it as a controlled dense unitary, so its cost grows with the number of branches and exponentially with the number of system qubits. The qsp_block_encoding backend already realizes the whole SELECT at once. It evolves, with QSP Hamiltonian simulation, the joint generator sum_j |j><j| (x) (k_j L + H) of Pocrnic et al., arXiv:2506.20760v2, Sec. IV, which NWQLib builds from separate L and H block encodings instead of one encoding of A. It has a query-cost law and an error allowance within the LCHS budget. It must be selected explicitly, its polynomial degree is limited by max_qsp_degree (256 by default) while the degree it needs grows with the kernel cutoff times the evolution time, and a dense input can give it block-encoding children that need dense synthesis.

The planned work makes a construction that builds every branch from block encodings of L and H the default quantum route for problems beyond small validation sizes. It extends qsp_block_encoding or replaces its polynomial transformation, whichever the state of the art supports when the work starts. Generalized QSP (Motlagh and Wiebe, arXiv:2308.01501v2), which Classiq's LCHS notebook uses, is one candidate.

The work needs access to L and H that does not start from a dense matrix, a way to reach the degrees that long evolutions need, and a default route that depends on the problem size. A replacement transformation also needs its own query-cost law and error composition with the existing kernel and quadrature budgets. Small cases must agree with dense_exact and with independent matrix-exponential references.

Controlled dense-query construction

Exact dense synthesis describes how NWQLib synthesizes and controls dense unitaries and how each construction checks that work against its limits. The following points remain open.

• Dense input does not scale. The synthesis takes of order M³ classical work and M² gates for an M-square unitary, so a dense encoding serves small validation systems. A larger system needs a structured encoding with its own oracle, normalization, query count and ancillary workspace (scalable input and execution models).
• The gate-wise control law counts the synthesized gates of a controlled composite. Qiskit also controls the other gates of the composite, such as the projector phases of a QSP pass or the input preparation of a controlled LCHS source branch, and a backend then lowers the multi-controlled gates of the controlled circuit. These costs have no law.
• The parity control of a QSP pass controls the whole pass and is gate-wise on every route. Controlling the pass instruction by instruction would let the whole-matrix route reach a dense child at every query, and it would need its own CX and work laws.
• No limit of its own bounds the memory of the Run's synthesis cache. Each cached synthesis was reserved against max_synthesis_work, so at the default the kept-byte laws and keys of the cached circuits stay below about 2.1 GB, below 0.79 GB when every cached circuit has three or more qubits and below 0.41 GB when every one has four or more.
• A QLS notebook run on 2026-09-23 reached the max_steps=100000 admission budget of an optional full resource fold. That limit counts metadata traversal and arithmetic, not physical time steps or quantum gates. The cost of a full resource fold remains to be investigated with the Program that planning produced, without silently increasing the budget.

Scalable input and execution models

Users evaluating asymptotic advantage need problem-loading and Hamiltonian-access models that do not begin with a dense matrix.

Each algorithm needs an explicit oracle contract, cost model, and small independently checkable realization. A generic “sparse” flag would hide algorithm-specific assumptions and is not sufficient.

Time-dependent LCHS

Scientific dynamics applications may supply time-varying generators or source terms rather than the shipped constant operators.

The quadrature, evolution ordering, input records, and error composition must be designed together. Reusing the time-independent records without those semantics would create a misleading API.

QHD augmented-Lagrangian layer and box refinement

The augmented-Lagrangian layer and box refinement run one ordinary QHD Plan per round or level and search the finite grid of each box. They follow Wu et al. arXiv:2605.12066v1, Sec. III.B and Sec. V. The items below remain open. An item that would change a default needs an independent classical oracle or a derived bound first.

• Narrower eligibility for a quantum automatic default. Qualify a restricted class beginning with one affine inequality, KineticGroundState, joint-mode readout, no refinement and exact noiseless readout. Executed evidence currently covers only the three n = 3, K = 4 grid configurations under the settings that the guide's measured-evidence row for the comparison states, while the cases up to fourteen variables establish planning admission and resource counts. Qualification needs converted quantum trajectories that preserve feasibility and pass a predeclared best-feasible objective margin against PHR at matched budgets, checked against independent feasible-objective references. The resource evidence must also include native costs, representation-selection overhead, observed simulator time and total process memory. Quantum means, quantum refinement, finite shots, other initial states and other schedules remain untested by this study, and the classical sensitivity checks do not establish quantum time-step convergence.
• Scales. The augmented-Lagrangian layer takes the objective and constraint scales from the caller, with default 1. Estimating them from the problem, for example with the gradient-based factors that Algencan computes once at the starting point (Birgin and Martinez, doi:10.1137/1.9781611973365, Eq. (10.5)), or rescaling between rounds, would reduce how much the run's decisions depend on the units in which a constraint is written.
• Finite grid and continuous problem. Stopping statuses describe computed feasibility and complementarity at the selected points, and constrained_grid_minimum compares evaluated finite-grid values. A verifiable error relation between the finite-grid result and the continuous constrained optimum would let a grid result support a statement about the continuous problem. A narrower open question concerns the grid problem itself. With best_observed under exact readout, every grid point supported and no box refinement, each round's point is the grid point with the least binary64 table value of L_k, the smallest index on ties. Whether the convergence results of Birgin and Martinez, doi:10.1137/1.9781611973365, Chapter 5 (Assumption 5.1, Theorems 5.1 and 5.2), then apply to the finite-grid problem, with the grid taken as the book's lower-level set Omega, is not established, and max_penalty and the default absence of a safeguard depart from Algorithm 4.1 as those results assume it. The layer claims none of these results.
• Retry an unfinishable round or level. Durable resume cannot give an unfinishable inner Run a fresh attempt. Add an explicit opt-in that creates a new Run while keeping the old attempt's charged or uncertain work and charging the new attempt against the cumulative limits, so retrying cannot erase its cost.
• Finite-shot decisions. With shots, every round's point and every level's intervals are read from samples. Apart from the Hoeffding screen that admits a stall-split valley, the probability that sampling changed one of these decisions is not quantified, and the shots per round are not chosen adaptively.
• Feasibility restoration and polishing. A grid point rarely satisfies an equality exactly. A local feasibility restoration or classical polishing step would be explicit post-processing with its own budget, reported apart from the QHD result so that it does not enter the performance of the quantum part.

• Shared evidence and reports. An augmented-Lagrangian result keeps its own record and inner Results and has its own report and archive. It does not publish facts to Certificate or ErrorModel, and the CLI report command does not read its archive.

• Early-trigger refinement split. stall_split="best_region" acts only when the whole box stops changing, so for the same observations the best relative objective is never worse than that of the run without a split. Splitting as soon as one axis is kept whole and its marginal has two separated peaks did better on the double well of the QHD guide. With the search model at potential gain 1, the uniform initial state, max_levels=10 and max_no_improve=10, it split at the first level and reached best-point error 0.000857 in ten solves after discarding 5.7% of that level's distribution, where the stall split reached 0.0108 in ten levels. At the default gain 8, with the other settings unchanged, the double well does not stall within ten levels, so the stall split does not act, and the run reaches 0.00325. The early trigger changes the run before any stall and so loses that guarantee. It needs its own risk statement and an explicit decision before it becomes an option.

• Best-point Gaussian width and regime. level_initial_state="best_point_gaussian" has been compared only at width 1/6 of the level box, on one problem where it helped and on three two-variable problems where the kinetic ground state at every level did better (box refinement). A comparison over widths and problem classes that shows when the Gaussian helps would support a rule for choosing it, or a width set from the level's distribution.
• Application instances. An instance generator for the AC optimal power flow problems of Wu et al. would need an independent implementation and validation.

QHD core models

• Walsh reconstruction in IR comparisons. Propagate R_W into IR readout accuracy, the mode tie window and verification uncertainty. When the resulting uncertainty interval crosses the requested tolerance, report an inconclusive comparison so the decision does not exceed the available numerical evidence.

• Constant-phase report. Report the objective constant's phase contribution separately from the rest of the phase-sensitive ledger. This would help readers distinguish a global-phase contribution from errors that can change readout probabilities.

• Classical time integration. The integrated coefficient rule removes the quadrature error of the schedule coefficients but keeps the second Magnus term, and on the measured model, with s = 1 for the cubic schedules, both coefficient rules converge at second order with errors within 1% of each other. Whether a higher-order Magnus or interaction-picture classical model is needed depends on accuracy and cost evidence on a stated model.

• Kinetic terms below the normal binary64 range. Planning refuses a kinetic coefficient, energy, hopping term or one-hot kinetic phase whose exact value would fall below 2**-1022, and names the grid spacing and schedule weight as the remedy (algorithms/qhd/validation.py::_kinetic_range_error). With schedule weights of order one, only grids with spacing near 1e150 or wider reach this, for example K = 64 on a periodic binary box of width 6.4e154. The omission rule for objective data would extend to them: an analytic Walsh coefficient or dense energy used as zero and charged by its enclosure radius about that zero, a one-hot hopping occurrence charged at its exact intended weight, and a one-hot kinetic diagonal event charged at its exact identity action. This needs those radii in the binary angle-formation bound, the counts in QHDRangeOmissions and a public test per case.
• Binary encoding on Dirichlet grids. A sine-transform circuit for the Dirichlet kinetic term would let the binary encoding use the Dirichlet grids, which the current QHD limitations exclude.
• Odd K on the one-hot periodic grid. The second-order one-hot product splits each variable's links into two layers of disjoint links (kinetic.KineticCompiler). On a cycle of odd length K the wrap link (0, K-1) falls in the even layer and shares point 0 with link (0, 1), so the one-hot periodic grid requires an even K (method.QHD._periodic_grid). The rule also covers first order and the classical flavors, so that the periodic grids a Method admits do not depend on its product order or its execution. A compiler that splits odd cycles into three layers would admit odd K. It needs the third layer in the compiled step, its terms in the splitting bound of evolution_bounds, its CX and rotation counts, and a comparison of the emitted blocks with the circulant stencil at odd K.
• Start-vector bound on very large grids. The construction error bound of a product initial state charges gradual underflow of its tensor-product roundings as (d - 1) ceil(sqrt(K**d)) 2**-1074 (initial_state.restricted_state_error), which grows with sqrt(K**d). Planning therefore refuses a Gaussian state or the Dirichlet kinetic ground state once the bound in units of u leaves the binary64 range, from d = 2035 variables at K = 4, and names UniformState(), whose bound does not depend on the grid size, as the remedy. The refusal also stops resource-only and native Plans, although their native preparation acts on each register separately and forms no tensor product. Their error ledger uses the bound in its state_preparation entry. Admitting them needs a start term for that entry that does not rest on the host product, with its derivation, while the classical kernels, which form the product, keep the present bound.
• Split-step budget beyond first order. The Plan and observed state budgets of the split-step flavor are first order in u (split_step.state_error, split_step.evolve). A budget valid at every order in u would remove that premise from its mass and tie windows. It needs the higher-order terms of each charge in both budgets and a Plan ceiling for the tie window of the new observed budget.
• Dense phase-diagonal lowering error. The circuit error ledger (algorithms/qhd/resources.py::circuit_resources) has no bound for the lowering of a dense phase diagonal (subroutines/_multiplexors.py::append_control_diagonal_phases), which wraps each phase with NumPy's complex exponential and argument and forms the recursive means and Gray-code angles of the multiplexor. Its diagonal_wrap entry is therefore unavailable for a one-hot circuit with a number projector on 4 to 7 qubits and for a binary circuit with a dense diagonal, and those circuits have no native error total. A qualified error for NumPy's complex exp and angle and a rounding bound for the multiplexor recursion would give them one.
• Periodic Gaussian initial state. GaussianState uses the chart distance |x - c| of the coordinates in [lower, upper) on the periodic grid, so for a center near one end of the period the points across the wrap link get the amplitudes of their chart distance. A variant that moves with the center across the period would use the minimum image min_k |x - c + k L| for the period L, or a smoothly periodized Gaussian sum_k exp(-(x - c + k L)**2/(2 sigma**2)). Its application is the best-point Gaussian start of BoxRefinement(level_initial_state="best_point_gaussian") on a periodic grid, whose best point can lie near either end of the level box. It would be a separate option, so that states supplied with the current definition keep their meaning.
• Tie window with an excluded preparation. When Qiskit's state preparation lowers to an excluded unitary, the receipt has no state-error bound and the most probable point is chosen by exact comparison (Readout). A qualified window needs preparation-time information that the supplied matrices and their construction fit the per-instruction charge, or a separate bound eta_excluded on the excluded instructions, giving delta = (C G_covered/2 + 5) u + eta_excluded for the covered instruction count G_covered and the target's per-instruction constant C. That delta is relative to the stored native circuit, so a comparison with the finite model also needs the error of preparing its initial state and of compiling the model into the native circuit.
• Native readout cases without a witness. Two cases of the QHD readout windows have no test or witness (Readout). The tie window of exact native NWQ-Sim probabilities takes its state budget from the per-instruction constant NWQSIM_CPU_SV_ROUNDOFF_PER_OPERATION, and no native NWQ-Sim QHD run has compared its selection and window with an independent high-precision evaluation of the same circuit. The readout roundoff of exact native probabilities uses COMPONENT_SQUARES_ROUNDOFF, derived for a bin that holds one amplitude, which holds when the native circuit has no qubits beyond its register. The first case needs such a run with a qualified NWQ-Sim runner. The second needs a check of which QHD constructions add ancilla qubits and, for any that do, a readout window for bins that sum several amplitudes.
• State-dependent Schrodinger tie window. The schrodinger flavor charges each expm_multiply call its generator norm. A budget that follows the state, as the split-step flavor's does, needs the Taylor terms of SciPy's algorithm (Al-Mohy and Higham, doi:10.1137/100788860, Algorithm 3.2): with Z the scaled shifted generator and theta >= ||Z||_2, the term errors satisfy e_j <= (theta/j) e_(j-1) + r_j with a sparse-product defect r_j per term, and a geometric bound covers the tail after the actual Taylor degree m when theta < m + 2. SciPy returns neither the terms nor the selected degrees and scaling counts, so the bound needs an instrumented implementation with several O(D) reductions per Taylor term, or one more sparse matrix-vector product per term for the componentwise defect.

QHD objective expansion check

Before planning expands a QHD objective, it bounds the number of monomials the expansion forms (objective.monomial_bound) and checks that number against its work and byte limits. It also counts the nodes of each expanded term (objective.node_count) to bound the work of evaluating it on the grid. These counts miss the following cases.

• It does not count coefficient digits, so the default max_work accepts the expansion of (x+y)**1000000, whose binomial coefficients reach about 301,000 digits.
• A product of negative powers forms the product of their expanded denominators, which the monomial bound does not multiply. 1/((x+y)**400*(z+w)**400) is accepted as 401 monomials and forms 160,801.
• It does not model SymPy's log and exp rules. With positive variables log(x*y*z*w)**12 expands to 455 monomials, and exp(log(x+y+z)*(w+80)) to the 3321 monomials of (x+y+z)**80, while the bound counts one term for each objective.
• An unevaluated Sum or Product in the objective is lambdified as a loop over its range but counted as a few nodes, in planning and in the grid_minimum verification.

End-to-end certified resource estimation

A user who states a problem and a total error ε should receive resource counts together with a proof that the output meets ε. Current estimates identify their basis, precision, the set of circuits and shots they count, and their model scope, and several families bound some of their error sources, but no family composes every error source of its output into one budget with a certificate. The work needs end-to-end error budgets for QLS, LCHS and QPE, rotation and T-count formulas for every family, and certificates computed with interval arithmetic, so that rounding cannot move a bound. GCiM's physical-output bounds are a separate item. Two limits checked at planning also refuse large problems. The commutator census of QPE's error-budgeted product formula is admitted against max_work. With max_work=100000000 and 20 system qubits, the census alone admits initial full and relaxed envelopes of at most 531 and 8151 terms. An exact-trajectory Plan must also fit the common-step reservation determined by its power schedule and inputs, so these census-only figures are not exact-trajectory Plan term limits. The resource fold admits its work against a limit proportional to its Program's admission work, which a FixedGCIM plan with many settings exceeds (GCiM resource estimates for many settings).

GCiM physical-output error bounds and automatic assessment

FixedGCIM currently computes the projected energy, H/S matrices, overlap spectrum, selected rank, conditioning and numerical residual/backward-error diagnostics. Its default eigen_error_model declares six unresolved sources: native preparation, native simulation, sampling, projected solve, ground identification and physical modeling. Neither the quantum nor classical FixedGCIM analysis path automatically supplies the corresponding physical-output error facts. A default total result.assess(absolute_tolerance=...) therefore remains INCONCLUSIVE, including for a full trial basis. This describes an unfinished automatic bound-generation capability, rather than a failure to compute the projected energy.

The existing facts= interface consumes supplied bounds with matching output, frame and result context. It does not derive those bounds. Absolute-error assessment does not require the exact ground energy. Supplying reference= alone does not resolve missing error contributions. A known reference is useful for an independent development comparison, but it must not become a prerequisite for solving unknown scientific problems.

The next implementation should connect method-specific numerical and statistical analysis to the existing error model:

• Generate justified bounds for selected matrix-element acquisition and numerical reduction, including their units, assumptions and actual contributing observations. Distinguish a measured residual or variance estimate from a bound on the reported energy.
• Propagate supported H/S perturbations and overlap-cutoff effects to the selected projected energy, accounting for conditioning. Handle finite-shot covariance and confidence explicitly. Treat trial-space approximation and ground identification as separate questions whose bounds require additional problem-specific premises.
• Publish applicable bounds through the existing Result facts and persistence paths. Validate analytically checkable full-basis and partial-basis cases, an excited eigenstate with zero residual, and an ill-conditioned Gram matrix. A generic status change or an unconditional zero error term would not complete this work.

The bounds would be computed in algorithms/_eigen_support.py and the FixedGCIM planning and analysis code, and read by evidence/error_model.py and the stored projected checks in evidence/verification.py. ADAPT and Lanczos share the error-model constructor, so a change to it needs a separate check of the code that computes their bounds and of its assumptions. GCiM diagnostics remain usable while automatic physical-output bounds are developed.

GCiM resource estimates for many settings

The resource fold limits its work to max(max_steps, FOLD_WORK_PER_ADMISSION_STEP * a), where a is the Program's admission work. The factor is one traversal unit plus one unit for each of the 23 count metrics, 24 in all. These are metadata work units, not CPU time or resident-memory limits.

For the open Ising chain

\[ H=-\sum_{j=0}^{78}Z_jZ_{j+1}-0.7\sum_{j=0}^{79}X_j \]

on 80 qubits, use the two product trial states (cos(theta)|0>+sin(theta)|1>)**80 at theta=pi/8 and 3*pi/8, with 1024 shots per setting. This gives 159 Pauli terms. A measurement of this Plan on 2026-09-26 is recorded in an earlier version of the resource-estimation example notebook, from before sampled FixedGCIM measured its Pauli terms in qubit-wise-commuting groups. The Plan had 638 settings and was admitted, but its resource estimate was refused by the fold-work guard. That notebook's metadata records Python 3.12.14 and none of the other runtime versions or the platform. Now that sampled FixedGCIM measures its Pauli terms in qubit-wise-commuting groups, the same Plan has 8 settings and 8,192 shots, and its serial resource estimate succeeds (2026-09-30, planning only, Python 3.12.14, Qiskit 2.5.2, macOS arm64).

Supporting larger folds needs a measured or derived relation between their work, settings, Pauli terms and Program admission work. The earlier 638-setting witness does not establish a universal settings threshold, and no current Plan that exceeds the fold-work limit is recorded here.

ADAPT-GCiM analytic optimizer derivatives

Optional ADAPT reoptimization uses BFGS. Native modes supply the selected generalized or post-generator Pauli-insertion derivative rules, with lazy rule reuse and the original cumulative energy-query limit. Classical execution keeps finite differences, which repeat product-state/Hamiltonian work. An analytic or adjoint classical derivative remains possible future work.

The derivative must be derived for the shipped ordered-generator and normalization conventions, then checked independently across supported Hamiltonian and pool representations and increasing selected-chain length. This is an optimization of an optional path, not a prerequisite for the default ADAPT workflow.

ADAPT-GCiM stopping beyond the flat counter

Replace the consecutive-small-energy-change heuristic with a stopping rule supported by evidence about remaining improvement. A flat energy sequence can reflect an unproductive sequence of selected generators or insufficient measurement precision while the physical energy error remains large. The current min(T_auto, T_usr) rule therefore provides an operational stop, not an accuracy certificate.

Evaluate candidate rules at matched acquisition and classical-work budgets, including temporary plateaus, near-dependent basis vectors and finite-shot uncertainty. Distinguish a small projected eigensolver residual from convergence in the full Hilbert space. The design target is 20–25 qubits. Prefer already acquired matrix elements and structural evidence, account for work repeated at every iteration, and require explicit opt-in for additional full-space residual calculations, dense expansion or simulation. The stopping criterion is open research work and is coupled to the statistical questions below.

ADAPT-GCiM finite-shot adaptive statistics

The current quantum counts path returns point estimates and compares noisy gradients against a fixed selection floor. It does not quantify selection error across the pool. An exact-null or near-tie screen can choose sampling noise. Historical seed experiments are not current-source coverage guarantees.

A future result must record the complete gradient vector, per-setting counts or probabilities, independent seed streams, variance estimates, confidence intervals, the multiple-comparison method, and the separation between the winner and its closest competitor. It must report an unresolved selection outcome when the evidence does not separate candidates.

Finite-shot residual certification remains unresolved. Current sampled-pencil diagnostics keep their actual sources and do not become deterministic spectral or convergence guarantees. A future residual certificate needs a joint statistical model for every contributing quantity. Clipping an inconsistent estimate cannot supply that model.

Within one ADAPT run, gradient and matrix-element circuits consume a shared increasing sequence of simulator seeds. Distinct seeds do not establish statistical independence. A certified study still needs justified independent substreams or a covariance model that accounts for shared randomness.

Quantum exact and counts execution paths remain available. Finite-shot adaptive selection and finite-shot residual certification remain statistically unresolved and are not certified convergence evidence.

Structured Dalzell coefficient recovery

The Dalzell kernel-reflection polynomial has known even structure, but the current constructor samples it on a degree-dependent grid and recovers coefficients with dense Chebyshev least squares. A recurrence or stable orthogonal-transform construction could reduce classical coefficient-generation cost at large degree.

A replacement must preserve the coefficient convention, even parity, the K(0)=1 anchor, and the off-kernel bound -1 <= K(x) <= -1 + 4 eta/(1 + eta) for 1/kappa <= |x| <= 1, with independent large-degree stability comparisons. The existing fit remains the validation-scale fallback until those checks establish equivalence. This item is separate from the shortcut Program's composition of child block-encoding queries.

Preparing every setting on remote backends

prepare(plan, settings="all") prepares every static setting only on local Aer, local NWQ-Sim and classical host execution (Run on a backend). Extending it to IBM Runtime, IonQ, Nexus, Slurm and other remote backends needs two decisions. The first concerns cost. A remote preparation can be a compilation that the provider performs and may charge for, so preparing every setting in advance commits that cost for settings that a later cancellation or failure would never submit, and the caller needs to see that cost before the request. The second concerns pending preparations. A remote compilation can remain pending as a PendingPreparation, and the Run never repeats a preparation attempt on its own. Preparing every setting therefore needs defined behavior while some settings are still pending, namely what Prepared.circuits and Prepared.setting_names expose and how a later submit or a reopened Run advances the pending compilations without a second attempt and without submitting a setting from prepare.

Hardware-backed scientific validation

Provider adapters should eventually support reproducible algorithm-owned decoding and validation beyond mocked submission contracts.

Stable credentials, backend selection, calibration provenance, and statistical acceptance criteria must be supplied by a concrete study. Provider-neutral infrastructure alone cannot define scientific success.

Device fit and run-time forecasts

Check device fit and run time answers whether a Plan fits a declared device and how long it may take only in part. Three gaps remain:

• The built-in AER_STATEVECTOR_TARGET declares its readouts but not its artifacts, instructions or Program steps, so its capability check is unknown until the user declares them with AER_STATEVECTOR_TARGET.revise(...) (Assess a plan against a device).
• A finite time model needs an exact logical operation count. A Plan whose operation count is unavailable, such as the QLS example of Estimate resources, gets an unavailable time prediction (Finite time models).
• A residual between a forecast and a measured Aer time needs the forecast's runtime and compiler to equal those in the preparation record. The Aer adapter builds these sources internally and NWQLib exports no constant for them, so a user copies them from run.data.receipts[0] (Compare forecasts with measured times).

Closing these gaps needs built-in targets that declare what Aer supports, logical operation counts for the Plans that lack them, and public runtime and compiler sources for Aer.

Resource-model calibration

Analytic and block-derived estimates should be compared with transpiled circuits on representative architecture families.

Calibration requires a declared gate set, coupling map, transpiler configuration, and versioned hardware assumptions. The result must remain separate from portable algorithmic resource laws.

Larger scientific reference studies

Each algorithm would benefit from additional reproducible instances spanning more realistic parameter regimes.

New fixtures need stable provenance, runtime budgets suitable for reproducible validation runs, and an independent reference that does not reuse the implementation under test.

Possible extensions

These extensions require a concrete use case, input data, and an independent validation method before work begins:

• Additional QPE estimators or broad estimator benchmark matrices.
• Additional low-level synthesis backends.
• New chemistry excitation pools beyond the shipped fixed and adaptive choices.
• Provider-specific convenience layers beyond the common admitted execution path.
• Cross-series dependency rehearsal that ignores provenance-only version fields while still comparing all scientific golden values.
• Visualization and report front ends beyond the structured records and JSON reports already emitted by workflows.

Before implementing an extension, define its scientific input, public contract, independent validation method, resource limits, and effects on existing checks. Listing an extension here does not promise future compatibility.