Analytical Quantum Cost Model Explained

• The analytical quantum cost model is a framework that quantitatively assesses quantum computations by linking program semantics, gate timings, and resource constraints.
• It integrates various techniques, including expectation transformers, calibrated latency models, and fault-tolerant mapping to physical qubits.
• This model enables researchers to compare algorithmic cost, execution time, and measurement shot budgets for both pure quantum and hybrid classical-quantum workloads.

An analytical quantum cost model is a formal framework that assigns a quantitative notion of cost to a quantum computation, circuit family, testing protocol, or hybrid workload. In the recent literature, that cost may be the expected cost of a mixed classical-quantum program, the wall-clock time of a transpiled circuit on a calibrated backend, the number of physical qubits and cycles required under a surface-code architecture, the number of measurement shots needed for verification, or the value and concentration behavior of a variational cost observable (Moser et al., 5 Apr 2026, Kashif et al., 28 Feb 2026, Harrigan et al., 2024, Miranskyy, 25 Oct 2025, Friedrich et al., 2023). This suggests that the term denotes a family of related analytical techniques rather than a single canonical formalism.

1. Formal meanings of cost in quantum computation

The literature defines cost at several abstraction levels. In semantics-based program analysis, cost is attached to program statements and accumulated through transformer semantics; for a complete program $P$, the expected cost can be written as

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$

where $\sigma$ is the initial classical-quantum state and $0$ is the zero continuation (Moser et al., 5 Apr 2026). In hybrid quantum-classical training, cost is represented directly in seconds, with

$$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$

and total hybrid cost given by

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$

This formulation makes quantum and classical components commensurable in a unified time-based representation (Kashif et al., 28 Feb 2026).

At the fault-tolerant architecture level, cost is often split into physical qubit count and runtime. Qualtran reports architecture-independent logical counts such as $N_{\mathrm{logical\_qubits}}$, $T$-count, Clifford count, and logical depth, then forwards them to a surface-code cost model that estimates physical qubits and wall-clock time (Harrigan et al., 2024). FLASQ instead uses spacetime volume and reaction-depth constraints, with total spacetime volume

$S = Q\cdot L + V$

measured in blocks, where $Q$ is simultaneous logical patch usage, $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$0 is logical timesteps, and $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$1 is fluid-ancilla volume (Huggins et al., 11 Nov 2025).

Other analytical models take cost to be statistical or algorithmic rather than temporal. In variational quantum circuits, the cost function is the expectation value

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$2

and analysis focuses on its mean, variance, and concentration as a function of ansatz expressivity (Friedrich et al., 2023). In quantum program testing, cost is the shot budget required to distinguish actual and ideal states under an error tolerance $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$3 (Miranskyy, 25 Oct 2025). In query complexity, cost may be the weighted sum of oracle uses,

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$4

with each oracle $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$5 assigned a nonnegative cost $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$6 (Kimmel et al., 2015).

2. Expectation-transformer models for program cost

A central line of work models cost through quantum expectation transformers. In "Automated Expected Cost Analysis for Quantum Programs" (Moser et al., 5 Apr 2026), a program state is a pair $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$7, where $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$8 is a classical store and $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$9 is a density operator on the qubit Hilbert space. An expectation is a function $\sigma$0, and the transformer

$\sigma$1

is defined inductively. Representative clauses are

$\sigma$2

$\sigma$3

and

$\sigma$4

where $\sigma$5. For sequencing and conditionals, the transformer composes or mixes expectations pointwise, and for loops it uses the least fixed point

$\sigma$6

Cost is introduced by enriching the language with $\sigma$7, interpreted as adding $\sigma$8 units of cost. The expected-cost operator is then obtained by reading $\sigma$9 as

$0$0

For a complete program, one chooses the zero continuation $0$1 and computes $0$2. The framework supports mixed classical-quantum programs with mid-circuit measurements and classical control flow, and Qet automates the analysis through four phases: symbolic transformer, cost-constraint generation, polynomial constraint reduction, and certificate synthesis via SMT using Handelman’s Theorem-style certificates and Z3 (Moser et al., 5 Apr 2026).

The same semantic idea extends to higher-order quantum programs. "Expectation-based Analysis of Higher-Order Quantum Programs" (Avanzini et al., 25 Apr 2025) studies a quantum language extending PCF with unbounded recursion, classical and quantum data, and a tick operator $0$3. Costs are interpreted through a cost-structure $0$4, a pointed $0$5-Kegelspitze equipped with continuous cost addition. Specializing $0$6 yields different analyses: $0$7 gives average-case cost, $0$8 gives worst-case cost, and $0$9 gives event probabilities. The quantum expectation transformer $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$0 translates a quantum term into a non-quantum functional language enriched with operations over $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$1, and the exactness theorem states

$$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$2

A refinement type system then derives upper bounds compositionally.

Worked examples in both frameworks show the style of reasoning. In the first-order setting, the program “quantum coin-toss until heads” has expected cost $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$3, since the loop equation is

$$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$4

(Moser et al., 5 Apr 2026). In the higher-order setting, a recursive cointossing term yields expected cost $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$5, where $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$6 is the probability of measuring outcome $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$7 on the input state $$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$8 (Avanzini et al., 25 Apr 2025).

3. Hardware-calibrated latency models for NISQ and hybrid systems

A different analytical tradition treats cost as backend-specific execution time. "Closing the Loop: Resource-aware Hybrid NAS Guided by Analytical and Hardware-Calibrated Quantum Cost Modeling" (Kashif et al., 28 Feb 2026) defines a quantum cost model for hybrid quantum-classical neural networks that incorporates real backend calibration data, routing overheads, and noise-induced sampling inefficiency. The model begins with median backend durations

$$T_{\mathrm{quantum}} = N_{\mathrm{eval}} \times T_{\mathrm{eff}}, \qquad T_{\mathrm{quantum,total}} = N_{\mathrm{steps}} \times N_{\mathrm{eval}} \times T_{\mathrm{eff}},$$9

for single-qubit gates, two-qubit gates, and measurement, together with transpiled counts

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$0

The raw physical gate time is

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$1

Connectivity constraints are handled analytically through post-transpilation two-qubit overhead. If $$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$2 is the logical two-qubit count and $$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$3 the post-transpilation count, then

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$4

and the logical circuit time is

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$5

This separates algorithmic gate content from routing inserted by the compiler.

Noise is represented by two failure modes. Gate errors are aggregated as

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$6

and decoherence is modeled by

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$7

Assuming independence,

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$8

so that effective execution time becomes

$$C_{\mathrm{total}} = T_{\mathrm{classical,total}} + T_{\mathrm{quantum,total}}.$$9

The factor $N_{\mathrm{logical\_qubits}}$0 is explicitly interpreted not as a literal hardware retry, but as a time inflation accounting for extra shots required to maintain the same statistical confidence (Kashif et al., 28 Feb 2026).

Training-time overhead is then added through the parameter-shift rule. With $N_{\mathrm{logical\_qubits}}$1 trainable parameters,

$N_{\mathrm{logical\_qubits}}$2

and the per-step and full-training quantum costs are $N_{\mathrm{logical\_qubits}}$3 and $N_{\mathrm{logical\_qubits}}$4. The worked 2-qubit example in the paper uses $N_{\mathrm{logical\_qubits}}$5, $N_{\mathrm{logical\_qubits}}$6, $N_{\mathrm{logical\_qubits}}$7, $N_{\mathrm{logical\_qubits}}$8, $N_{\mathrm{logical\_qubits}}$9, $T$0, $T$1, $T$2, and $T$3, producing $T$4 (Kashif et al., 28 Feb 2026).

The paper also states the approximations that keep the model analytical and lightweight: independence of gate and decoherence failures, uniform median durations and error rates, a single-exponential decoherence model, linear routing overhead in extra two-qubit gates, constant shot execution time, and the parameter-shift rule for all gradients (Kashif et al., 28 Feb 2026). A recurrent misconception addressed by this line of work is that FLOPs or gate counts alone are adequate proxies for quantum hardware cost; the model explicitly argues that gate durations, limited qubit connectivity, and noise determine the true cost and scalability of quantum circuits.

4. Logical-to-physical and spacetime models for fault tolerance

For fault-tolerant estimation, analytical quantum cost models usually map logical resources to physical hardware resources. Qualtran reports at the logical level the peak number of logical qubits, gate counts such as $T$5-count, Toffoli-count, Clifford count, arbitrary-angle rotations, and an optional logical depth estimate (Harrigan et al., 2024). To obtain physical costs under a surface-code architecture, one chooses a data-block design, a magic-state factory layout, and code distances $T$6 and $T$7. In the rotated surface code, one logical qubit occupies exactly $T$8 physical qubits, giving

$T$9

Code distance is set by an error-suppression constraint. A common phenomenological fit is

$S = Q\cdot L + V$0

and one requires roughly

$S = Q\cdot L + V$1

for the data block, with a corresponding bound for factory failures (Harrigan et al., 2024). Runtime combines logical depth and $S = Q\cdot L + V$2-state production rate. If each factory supplies $S = Q\cdot L + V$3 $S = Q\cdot L + V$4-states per cycle, then

$S = Q\cdot L + V$5

For a 15-to-1 Reed-Muller factory, the footprint is roughly $S = Q\cdot L + V$6 tiles and $S = Q\cdot L + V$7 cycles per output, so

$S = Q\cdot L + V$8

per factory per cycle (Harrigan et al., 2024).

The four-site Hamiltonian-simulation example reported in Qualtran uses $S = Q\cdot L + V$9, $Q$0, $Q$1, $Q$2, $Q$3, and $Q$4. The resulting choices $Q$5, $Q$6, and $Q$7 yield $Q$8, $Q$9, and a qubit-time product of approximately $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$00 (Harrigan et al., 2024).

FLASQ generalizes this style of accounting to early fault-tolerant devices with a fluid-ancilla abstraction. Its basic variables include code distance $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$01, cycle time $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$02, reaction time $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$03, total logical patches $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$04, simultaneous data-plus-algorithmic-ancilla usage $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$05, available fluid ancilla $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$06, measurement depth $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$07, total non-Clifford count $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$08, ancilla volume $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$09, and total spacetime volume

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$10

measured in blocks (Huggins et al., 11 Nov 2025). One block is the spacetime volume of a single logical qubit for one logical timestep: $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$11 physical-qubit-cycles. The temporal schedule is determined by two constraints: $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$12

FLASQ assigns explicit ancilla-volume costs to gates. In the conservative model these are $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$13 for $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$14, $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$15 for $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$16, $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$17 for a CNOT or CZ between qubits at Manhattan distance $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$18, $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$19 for a move over distance $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$20, and $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$21 for single-qubit basis measurement or initialization. A $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$22 gate is split into cultivation and injection, giving total per-$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$23 volume

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$24

The model is designed to capture overheads neglected by simpler metrics: the paper states that $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$25-count or circuit depth alone neglect routing and Clifford cost and can be off by orders of magnitude in a 2D surface code, while relative runtimes can differ by factors of $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$26–$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$27 compared with depth-only or $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$28-count-only forecasts (Huggins et al., 11 Nov 2025).

5. Variational, testing, and measurement-statistical notions of cost

In variational quantum machine learning and related optimization settings, the cost model may refer to the cost observable itself and the way its distribution depends on ansatz expressivity. "The quantum cost function concentration dependency on the parametrization expressivity" (Friedrich et al., 2023) defines

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$29

with $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$30 and Hermitian observable $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$31. Expressivity is quantified through

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$32

where $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$33 measures deviation from the Haar moment operator at level $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$34. For the first moment,

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$35

with $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$36. For the second moment, the paper derives

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$37

As $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$38, the cost function approaches its Haar-limit mean and variance. If $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$39 is traceless, then $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$40 and $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$41 as $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$42. The paper explicitly connects this concentration behavior to barren-plateau phenomena and also notes its assumptions: Chebyshev’s inequality may be loose, the ensemble is treated as an approximate unitary $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$43-design, and the results are two-norm worst-case bounds (Friedrich et al., 2023).

Verification and testing introduce another statistical notion of cost: the number of measurement shots required to certify fidelity or distinguish states with bounded error. "The Cost of Certainty: Shot Budgets in Quantum Program Testing" (Miranskyy, 25 Oct 2025) derives shot-count formulas from the quantum Chernoff bound and fidelity. For pure-state inverse testing,

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$44

while for the swap test,

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$45

The paper states that the inverse test is the most measurement efficient, the swap test requires about twice as many shots, and the chi-square test is easiest to implement but often needs orders of magnitude more measurements. At the program level, a global fidelity target $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$46 is converted into a Bures-angle budget

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$47

which is then distributed across subroutines using

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$48

Because per-block shots scale like $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$49, fine-grained decompositions can become impractical; the paper reports that budgets may grow to $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$50–$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$51 shots per block (Miranskyy, 25 Oct 2025).

A related but distinct analytical model appears in QC-AFQMC, where quantum and classical costs are coupled. "Classical and quantum cost of measurement strategies for quantum-enhanced auxiliary field Quantum Monte Carlo" (Kiser et al., 2023) counts the number of overlaps needed for the importance function, force bias, and local-energy estimates, then analyzes both the required number of snapshots and the classical post-processing cost. With classical shadows, the number of measurements needed to estimate all $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$52 overlaps with additive error $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$53 scales as

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$54

for $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$55-qubit Clifford shadows and

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$56

for matchgate shadows. The dominant per-overlap post-processing cost is $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$57 for matchgate shadows and $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$58 for orbital-rotation shadows; since each walker needs $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$59 overlap computations for local energy, the paper derives

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$60

under the stated growth assumptions (Kiser et al., 2023). The analysis also identifies covariances between overlap estimations along walker trajectories and propagates overlap error into AFQMC energy error.

6. Weighted-query models, automated estimators, and methodological tensions

Analytical quantum cost models also appear in query complexity. "Oracles with Costs" (Kimmel et al., 2015) assigns each oracle $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$61 a nonnegative cost $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$62, so a quantum algorithm $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$63 that makes $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$64 calls to $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$65 has total cost

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$66

The corresponding complexity measure is

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$67

the minimum cost over algorithms computing $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$68 with error at most $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$69. For Search with Two Oracles, the paper proves asymptotically optimal cost

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$70

and gives a hybrid amplitude-amplification strategy that interpolates between direct Grover search and a two-stage search through the cheaper oracle (Kimmel et al., 2015). This formalism treats cost as a first-class analytical variable rather than a uniform query count.

Automation is pushed further in "Traq: Estimating the Quantum Cost of Classical Programs" (Peduri et al., 1 Sep 2025). Traq starts from a first-order SSA language, Protolang, with a search primitive

$$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$71

which classically corresponds to $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$72 search over the last argument but is compiled into Grover-style search in $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$73. It defines an input-dependent expected quantum cost $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$74 and a worst-case unitary cost $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$75, both non-asymptotic and carrying exact constant factors. Theorems in the paper show that compilation preserves approximation guarantees and that actual expected cost is upper-bounded by the analytical estimate. In the depth-2 AND-OR-tree case study, the resulting bound scales as $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$76, and a proof-of-concept evaluation reports a crossover in favor of the quantum estimate around $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$77 for the toy constants used (Peduri et al., 1 Sep 2025).

Across these models, a persistent methodological tension is that different cost metrics are not interchangeable. Gate counts ignore calibrated durations, routing, and noise in NISQ settings (Kashif et al., 28 Feb 2026). $$\mathrm{Cost}(P)(\sigma)=\mathrm{wpt}(P,0)(\sigma),$$78-count and depth alone can miss routing and Clifford overheads in surface-code layouts (Huggins et al., 11 Nov 2025). Shot-count estimates based only on Chernoff asymptotics may understate the cost of noise-calibrated verification, since baseline binomial tests can exceed the theoretical estimate by orders of magnitude when the calibrated baseline and actual success probabilities are close (Miranskyy, 25 Oct 2025). Semantics-based program analyses deliver precise upper bounds, but they rely on fixed-point reasoning, invariant synthesis, and symbolic constraint solving (Moser et al., 5 Apr 2026). This suggests that an analytical quantum cost model should be interpreted primarily by the operational question it answers—expected program cost, hardware latency, physical-resource demand, shot budget, or cost-landscape behavior—rather than by the shared phrase “cost model” alone.