27Counting the complete logical workload

Begin with the scientific contract, not a qubit number

Lesson 26 established the target and evidence record: a specified molecular model, state/sector, energy convention, approximation budget, and statistical success criterion. Resource estimation prices a computation that satisfies that contract. It cannot decide afterward that a cheaper active space, a different eigenstate, or one favorable phase bin answered the same question.

Our main example remains neutral, intended-singlet N₂ at 1.85 Å, with the selected six-electron, six-spatial-orbital model derived from a 28-spatial-orbital cc-pVDZ calculation. Its twelve occupation qubits are only the beginning of a workload description. The phase controls, state loading, repeated evolutions, workspace, measurement, and repeated attempts also matter.

A logical resource count describes idealized operations and registers before a complete physical error-correction implementation is chosen. It is not a physical qubit count, purchase price, cloud bill, or measured runtime. Even the word logical has a scope: an algorithm-level circuit can contain ideal qubits and rotations, while a later compiled logical instruction set expresses operations to be implemented on protected qubits. State which level is being counted.

No program is compiled, counted, simulated, or estimated in this lesson. Equations are accounting rules; numerical illustrations are explicitly arithmetic or attributed source settings.

Width, peak live allocation, count, and depth

Width is the number of qubits in a specified register or circuit interface. Peak live allocation is the maximum number simultaneously needed during the chosen execution. An operation can take twelve system qubits but internally allocate a temporary twelve-qubit vacuum register, comparison bits, or QROM output words. Its peak can therefore exceed its argument width.

The Circuit.num_qubits field is an optional declared argument-register width and excludes internally allocated scratch. It is not automatically overwritten with an estimator’s width. The Circuit tests deliberately give a declaration differing from a program’s counted width and check that the discrepancy is reported rather than silently redefining the field. Counting follows the supplied representation and its execution structure, not an arbitrary declaration alone.

Gate count counts occurrences of specified operations. Depth counts dependency layers under a stated model of which operations may occur in parallel. Two disjoint one-qubit gates can share a layer; two successive gates on the same qubit cannot. Ten thousand gates with substantial parallelism can have less depth than a long serial chain, but their physical realization can require more simultaneous hardware or factory throughput.

Measurements, resets, and classical feedback are also operations with dependencies. A correction that depends on a measurement cannot occur before that result is available. A count of T gates alone omits those dependencies and latencies. A logical depth is not a duration until a model assigns times, parallelism, routing, and feedforward behavior.

Do not sum peak widths across sequential independent shots. If each shot uses the same machine and releases its scratch, the campaign width is approximately the maximum per-shot requirement, not the sum of all shot widths. Gate work and sequential runtime do accumulate. Parallel shots reverse that tradeoff: simultaneous copies can reduce elapsed time while increasing aggregate hardware, storage, and factory demand.

Which operations are being counted

Clifford gates such as H, S, and CNOT preserve Pauli structure under conjugation. The T gate, with action $\operatorname{diag}(1,e^{i\pi/4})$, is non-Clifford. Generic arbitrary-angle rotations require another level of approximation when the target protected instruction set does not implement them natively.

A Toffoli, or CCX, flips a target conditional on two controls. A CCZ is related by Hadamards on the target, but its implementation may use a specialized resource state rather than the same T-gate decomposition as an arbitrary compiler’s Toffoli. The estimator can also report ccixCount, a distinct controlled-iX primitive count. Do not merge all such categories into “T gates” without specifying the conversion model and avoiding double counting.

The repository’s count-consuming tests use fields such as numQubits, tCount, rotationCount, cczCount, ccixCount, and measurementCount. These are not necessarily an exhaustive histogram of every source-language gate or a complete dependency graph. Some external count formats additionally describe rotation depth. The exact returned schema is a versioned external QDK contract; inspect it rather than inventing a totalGateCount field or treating one summary as a gate-by-gate physical schedule.

The state-preparation tests distinguish arbitrary rotations, explicit T/CCZ work, and measurements. They demonstrate the intended distinction between a Clifford-only expansion and binary compression that exchanges non-Clifford work for measurement-based uncomputation. Their reference counts are fixture-specific, not newly calculated universal costs.

For a product-formula factor $e^{-i\theta P}$, an elementary implementation uses basis changes, a parity network, an axis rotation of angle $2\theta$, and uncomputation. The Pauli word’s support, the ordering of adjacent factors, and compilation optimizations determine the gate sequence. A term count is therefore an input to circuit accounting, not the final T count.

Rotation precision changes the workload

Suppose a circuit contains R synthesized rotations and rotation j has operator-approximation error bounded by $\epsilon_j$. Under compatible unitary norm assumptions, a conservative composition bound is $\sum_j\epsilon_j$. Uniformly allocating a total rotation tolerance $\epsilon_{\mathrm{rot}}$ would give each rotation a tolerance around $\epsilon_{\mathrm{rot}}/R$. This is an illustrative budget rule, not a promise that a particular compiler uses equal allocation.

Tighter synthesis typically requires more non-Clifford resources. Many synthesis methods have approximately logarithmic dependence on inverse error, with method-dependent constants and assumptions. The direct QRE example later exposes a count-per-rotation choice rather than asking the chemistry package to derive a universal T cost from one angle. A T count itself still does not choose the distillation protocol or physical factory architecture.

Keep separate the tolerances for chemical-model energy, integral factorization, Pauli screening, time-evolution approximation, state loading, rotation synthesis, phase resolution, sampling, and logical failure. A parameter called precision in a QROM loader quantizes a table of angles; target_accuracy in a product-formula builder refers to its own approximation estimate; a QEC error budget concerns failure under a hardware model. None is a universal substitute for the others.

A controlled operation can expose an otherwise global phase. Thus a synthesis optimization acceptable for an isolated state preparation may not preserve a later controlled unitary. Count the valid controlled construction, not an apparently cheaper phase-discarding surrogate.

State preparation, scratch, and reusable resources

Let $C_A$ denote the logical cost of preparing the trial state A from its defined initial register. Every fresh measured shot normally pays that cost. Reading a classical CI coefficient file once does not load all future quantum shots for free. The classical preprocessing and the repeated coherent loading are different entries in the ledger.

For ordinary sparse isometry, a reduced dense-loading subregister is expanded back to the full occupation register. Reducing the number of loaded amplitudes does not remove physical modes from the final state. The create_dense helper provides only a costing component, not the complete requested state; matched additive logical counts can help isolate expansion, but subtracting two optimized physical estimates need not isolate one module’s cost.

QROM and alias sampling introduce address, comparison, flag, data, and other working registers. Alias sampling can leave index-dependent garbage that is valid in a complete PREPARE/SELECT/PREPARE-adjoint block contract but not as a clean arbitrary chemical trial state. Count the actual compatible routine, not a histogram-equivalent state that would fail coherent use.

The qrom loader makes phase-gradient ownership explicit. With internal allocation, the callable prepares its own gradient and its declared width contains only the state register. With shared allocation, its argument width includes the gradient suffix and num_phase_gradient_ancillas records it. The caller must initialize that suffix, preserve it, and exclude it from zero-ancilla reflections.

The standalone QROM factory always prepares its own gradient even if the composable callable expects one from its caller. Estimating that factory and estimating a larger composed circuit with one shared gradient are different experiments. A shared catalyst may be amortized across many operations inside one execution, but its preparation, storage lifetime, cleanup, and physical protection are not free, nor automatically shared across independently initialized shots.

Uncomputation can reduce live scratch by returning it to a known state for reuse. It usually adds gates, or uses a measurement-and-feedforward alternative with a different cost. A compiler must preserve the clean-workspace promise. Simply resetting an entangled helper is not a cost-equivalent replacement for valid uncomputation.

The complete QPE geometric sum

Assume the intended controlled powers are powers of one fixed base unitary U. Standard m-bit QPE calls powers $1,2,4,\ldots,2^{m-1}$. If power r is implemented by r repetitions of the same base operation, the total number of base-unitary uses is

The largest single power is $2^{m-1}$. It is close to half the sum for large m, not the whole experiment. State preparation and Fourier/measurement overhead must be added separately.

For a coherent standard-QPE shot, state preparation is paid once, followed by all controlled powers and inverse QFT. With S complete shots and R independent runs of that same full experiment, the nominal repeated-U count is $RS(2^m-1)$ and preparation count RS. Whether those runs are actually independent and what summary is reported are statistical decisions outside this arithmetic.

For the repository’s fresh-state-per-bit IQPE, let s be shots per bit and R the number of complete bitstring runs. Under the same repeated-base-U assumption, the nominal count is again

but trial preparation occurs $Rsm$ times. Each bit circuit also has its own control initialization, feedback rotation, measurement/reset, and circuit execution overhead. The classical algorithm’s majority vote and feedback are part of the workflow, not more coherent quantum gates automatically embedded into one circuit object.

The main 1.85 Å tutorial specifies m=6, s=3, and twenty complete runs. Substituting those source settings gives 360 trial preparations/bit shots and 3780 base-unitary applications. If one also uses the documented 247-term snapshot and one unmerged first-order sweep per base U, the simple invocation ledger is 933,660 Pauli-exponential calls before compiler-level decomposition/cancellation. This is arithmetic from stated snapshot assumptions, not a newly executed count or a claim about final T gates, depth, or physical qubits.

The same twelve problem qubits can be reused across those independent shots. A thirteen-qubit argument register for system plus phase control is still not the peak if a mapper internally allocates scratch. CSWAP control, for example, adds a system-sized vacuum register while covering repeated evolution with two swap layers. Its cost is not a constant multiplier of every base gate, and its vacuum-preserving ordered-block test must remain satisfied.

When powers cannot be counted by a simple multiplier

The shared builders distinguish power_strategy="repeat" from rescale. Repeat preserves a chosen base approximation and repeats it; rescale rebuilds an approximation at a longer simulated time, possibly changing the number of divisions, samples, and coefficients. In that case count the actual generated circuit for each power. Do not replace it with $2^k$ times the base count without checking its construction.

Randomized products require an even more careful application boundary. A fixed seeded qDRIFT build may be repeated consistently, but its averaged-channel bound does not certify the coherent eigenphases of one compiled product. Nondeterministic rebuilding can yield different unitaries across phase bits rather than powers of one U. A cheap count for an inconsistent phase-estimation experiment is not a useful resource result.

Long powers also amplify approximation errors. A base unitary error bounded by $\epsilon_0$ can accumulate conservatively to $r\epsilon_0$ after r repetitions. The builder’s base-time automatic accuracy choice does not necessarily tighten itself for every downstream repetition. The logical ledger should therefore include the accuracy assumptions that made its counts acceptable, not just the count of loops.

Unary and factorized walks have their own accounting units

The unary QPE builder uses p self-inverse block queries and p+1 reflection slots, addressed by $\lceil\log_2(p+1)\rceil$ phase qubits. A window-state preparation and unary address-control recursion replace the ordinary list of controlled binary powers. The schedule realizes signed powers and its measurement is a doubled-phase signal with a prior branch choice; it is not an equivalent counting shortcut for arbitrary U.

The Q# schedule uses resource-counting annotations to avoid repeatedly analyzing identical slots. Existing tests compare the optimized logical-count path with the literal schedule. Such annotations save the estimator’s analysis work; they do not mean the physical block queries disappear.

For ordinary LCU, one query contains coefficient PREPARE, signed SELECT, its adjoint, and the appropriate reflection/control structure. For SOSSA, the mapper provides an uncontrolled Adj-only unit-power block, with the unary consumer owning the outer reflection. Its generator rotations, conditional alias tables, spin selectors, retained ancillas, and internal scratch must be counted. A generic controlled-PSP mapper is not a supported replacement for that block.

The phase-gradient suffix can be shared between compatible preparation and block routines only with matching declared widths and initialization. The unary builder checks these relationships, unlike some simpler composition paths. Its current orchestration is limited to the sparse QDK interpreter because recursive Q# lowering does not support the alternative QIR execution route. A countable or interpretable construction is not automatically a generally exportable hardware program.

This means comparisons need common scientific and success targets, not merely equal numbers of “queries.” A Pauli exponential, an LCU SELECT, and a SOSSA block are different units of work with different normalization/precision relationships.

Success probability determines repeated work

For ideal coherent QPE on a trial state, a target eigenstate or target eigenspace contributes overlap weight, and finite phase resolution determines the probability that its branch lands in the accepted bin/window. Let p denote the complete experiment’s success probability after all those conditions are included.

If independent complete attempts each succeed with probability p, the probability of at least one success in R attempts is $1-(1-p)^R$. To make failure at most $\eta$,

The mean number of attempts until first success is $1/p$, a different quantity from a high-confidence fixed attempt budget. For a hypothetical p=0.2 and desired failure at most 0.01, the latter requires 21 attempts, not the mean value five. This is illustrative probability arithmetic, not a measured nitrogen success rate.

If p is only estimated, its uncertainty must be included—for example by using a defensible lower bound and budgeting the chance that bound fails. Correlated attempts, postselection bias, an unreliable success classifier, or evolving noise can invalidate the simple independent-trial formula.

Do not substitute the four-determinant nitrogen fidelity directly for p in fresh-state-per-bit IQPE. As Lesson 21 showed, bit votes can draw information from different eigencomponents and can form hybrid phases. The actual complete-run distribution and success criterion must be modeled or validated. The recorded twenty-run tutorial histogram is evidence for that specific demonstration, not a universal trial-count law.

Amplitude amplification changes the ledger rather than deleting repetitions. For k valid ideal rounds, the generic construction uses $2k+1$ preparation/adjoint operations and two good-flag oracle calls per round, plus reflections. A QPE-subspace flag oracle contains forward and inverse coherent QPE, so its literal cost can be four QPE-or-inverse operations per round before cancellations. The current oracle’s exact-grid/clean-ancilla limitations still apply; counting an invalid off-grid oracle does not establish a working speedup. Unknown p and overshooting can add further work.

Observable campaigns and time-series campaigns

For Pauli expectation estimation, shots are distributed across measurement groups. The current QDK estimator assigns each nonidentity group the same floor share of total_shots, dropping the remainder. Identity-only groups need no measured shots. Every surviving group shot prepares the state and executes the complete basis-measurement circuit.

A smaller group count does not guarantee a proportionally smaller shot budget: grouped covariance and coefficient weights determine the estimator variance. The current reported energy_variance omits within-group covariance, so it cannot automatically supply a justified minimum-shot estimate for a target confidence. Loss/postselection can reduce usable shots and change the relevant distribution; requested, allocated, clean, and accepted counts belong in the ledger separately.

For time-dependent dynamics, the current EulerIntegrator measures one final-time state per call, with a full preparation/evolution prefix. It does not retain a live unmeasured state across requested time points. On an M-point equal-step observation grid, separately executing prefixes of length 1 through M costs $M(M+1)/2$ interval uses per corresponding shot schedule, not M. Multiple observables and their groups add their own experiments.

A geometry campaign is another multiplier. Each geometry can require new SCF/orbitals, active-space decisions, integrals, trial support, and unitary parameters. Constant qubit count across a path does not guarantee constant factor ranks, coefficient norms, overlap, or gate cost. Preserve those differences rather than multiplying one favorable molecule’s count by the number of geometries.

The notebook’s largest-iteration estimate has a limited scope

The separate qpe_stretched_n2.ipynb uses a different nitrogen geometry, 1.270025 Å. Its resource section explicitly sets largest_circuit = iqpe_iter_circuits[0] and converts that single Circuit to a QRE application. The same pattern is used for its qubitization alternative. This is a component estimate of one largest bit circuit, not automatically the complete IQPE campaign.

Earlier notebook cells construct a ten-bit list, with the first circuit containing the largest power 512. A complete ten-bit repeated-base-U sequence sums to 1023. With three shots per bit, one complete run would contain 3069 base-U uses and thirty preparations, before any outer repetition policy. These are arithmetic counts under that construction, not estimates executed here. The notebook’s separate low-precision simulation example uses six bits, so its simulated result and ten-bit component resource section are not automatically the same workload.

The application adapter takes a Circuit; it does not inspect an external Python loop of shots/trials and add those repetitions. Likewise a bare largest-circuit estimate does not inherit the success-probability model, post-processing, or scientific error target from surrounding prose. State the scope in every plot title and result record.

The estimation_ising_2d.ipynb instead builds a selected state-preparation-plus-evolution circuit and scans resource-model assumptions. That is closer to a complete one-shot evolution task, but not automatically a multi-observable measurement campaign or a sweep over all times, sizes, and seeds. Its parameter alternatives are alternative machines/compilations, not copies to sum as though all were executed together.

A logical accounting ledger

For each distinct circuit family, keep a ledger such as this:

The classical part can be substantial: dense integral storage scales quartically in orbital count, correlated solvers can grow combinatorially, factorization and commutator planning can be expensive, and circuit/QROM tables can become large. Resource models of quantum operations do not automatically include workstation memory, queueing, network transfer, compilation latency, or analyst effort.

Dependency-aware depth can be reduced by parallelism only where the algorithm permits it and the architecture supplies the necessary resources. Independent experimental shots can run on separate machines, while adaptive bit feedback may force sequential decisions. Factory sharing, routing, memory lifetime, and classical control latency can constrain the achievable schedule. An unconstrained graph-layer depth is not a promised wall-clock time.

How Circuit exposes counts and estimation applications

The repository’s Circuit.estimate(params) uses the owning Q# factory context to obtain logical counts and then calls the estimator, or uses an OpenQASM estimation path. It accepts a parameter dictionary, a list of dictionaries, an external EstimatorParams object, or omitted defaults. It does not accept every Circuit representation: QIR-only and rendered-object-only inputs lack a route in this convenience method.

Circuit.get_qre_application() is an alternative adapter. It creates a QSharpApplication for factory data, otherwise an OpenQASMApplication, otherwise a QIRApplication, using the optional qdk.qre interface. Its QIR-only support differs from .estimate(). These are not mandatory successive steps. The resource-estimation guidance in this revision explicitly separates the two interfaces and warns that external QDK APIs evolve independently.

A minimal unexecuted inspection pattern, assuming a previously constructed suitable circuit and compatible installed dependencies, is:

# Convenience route: obtains this Circuit scope, not an external shot loop.
# result = circuit.estimate()
# logical = result.logical_counts
# width = logical["numQubits"]
# rotations = logical["rotationCount"]

# Alternative direct-QRE route, not the next mandatory step:
# application = circuit.get_qre_application()

No calls in that sketch were executed here. A result’s status/errors must be checked before reading counts. The convenience method does not infer the chemical model, ground overlap, independent trial count, or every surrounding classical loop from a Circuit object. A batch parameter list applies alternative estimator assumptions to the same circuit, not automatic workload multiplication.

QsharpFactoryData invokes its parameter values in insertion order as positional arguments. An incorrect ordering can count another program or fail; metadata names alone do not bind arguments. A factory is a program entry point, not necessarily a state-returning unitary: some reset outputs, some measure flags, and shared-resource ownership can differ from its composable callable.

Resource analysis can also encounter the same profile/lowering restrictions as execution. The Q# caching helpers in CircuitComposition.qs and unary scheduling annotations are intended counting semantics, not quantum memoization. For adaptive programs, document which branches, bounds, or model annotations the estimate represents; do not assume every reported scalar is a universal worst case.

A hypothetical whole-workload comparison

Suppose two hypothetical preparations cost 100 and 250 logical non-Clifford resource units, and a complete coherent eigenvalue test costs another 1000 units. Suppose independently validated complete-test success probabilities are 0.2 and 0.5. For failure at most 1%, independent-attempt budgets are 21 and 7, respectively. The corresponding simple serial work totals are 23,100 and 8,750 units.

This illustration shows why cheaper preparation alone does not imply cheaper completed science. It assumes a valid identifiable success event, independent attempts, equal costs per attempt, and no other overhead. It is not a nitrogen fidelity substitution, physical T-state estimate, or practical hardware comparison. If the success model is unsupported—as can happen when confusing fresh-bit IQPE with coherent QPE—the arithmetic becomes irrelevant.

Similarly, replacing some controlled gates by a CSWAP construction might lower non-Clifford gate count while increasing live qubits. A QROM gradient can amortize repeated rotation preparation while increasing protected memory. Those tradeoffs are exactly why a complete workload and a physical model are both needed, rather than a single “gate reduction” headline.

The handoff to fault-tolerant modeling

The next team or model layer needs a logical program or faithful trace, register lifetimes, operation categories and dependencies, synthesis precision, repetition structure, and the allowed parallelism. It also needs the total success requirement and the distinction between energy approximation, statistical confidence, and probability of logical failure.

The chemistry/algorithm side must supply the defined scientific target, state/sector evidence, and justified repetition policy. Compiler/synthesis modeling supplies a valid lower-level operation demand. Error-correction and hardware modeling will determine protected operation costs, cycle times, routing assumptions, and magic-state supply. These are functional responsibilities, not assertions about a particular organization’s internal ownership.

Once those inputs are explicit, a physical resource estimate can be informative. Without them, twelve qubits, a large T count, or one largest-iteration Pareto point is an incomplete description of the work. Lesson 28 explains why protecting those logical operations changes the machine so dramatically.