WorksPhysics and Astronomy
Reducing the arithmetic cost of quantum derivative pricing with language-model circuit design
Abstract
Quantum amplitude estimation can estimate expected discounted payoffs with quadratically fewer oracle calls than Monte Carlo, but each call requires coherent computation. We use language-model-assisted circuit design to reduce reversible payoff arithmetic for a three-asset worst-of autocallable and a target accrual redemption forward (TARF). The constructions retain compact integer representations of market paths alongside contract history, reconstructing quantities temporarily for contract decisions and payoff-angle evaluation. Relative to matched internal references, the factor-sum autocallable and windowed TARF circuits reduce the product of Toffoli count and peak logical qubits by factors of 2.39 and 4.84, respectively. At a second autocallable setting, fresh search recovers a 1.35-fold saving after the tested fixed adaptation loses its advantage. For the factor-sum circuit, we prove exact coherent execution of its integer specification for every input, incoming accumulator and measurement record, with clean workspace and phase cancellation. A separate lattice calculation gives a numerical angle-tolerance-violation probability of 6.248e-8 and evaluates pricing bias under the declared loading law, with bounded omission but no certified numerical enclosure. The results connect compact representations to lower-cost payoff arithmetic and separately assessed logical and financial correctness. Their resource scope excludes loading, payoff rotation and estimation.
Introduction and related work
Derivative pricing seeks an expected discounted payoff under a specified market model. Quantum amplitude estimation can estimate this expectation with quadratically fewer oracle calls than classical Monte Carlo [1, 2, 3], but each call requires coherent state preparation and payoff encoding. In arithmetic-based pricing constructions, path updates, contract decisions and nonlinear payoff evaluation contribute substantial logical cost [4]. We study this arithmetic component and how its approximation affects the pricing expectation.
Known approaches address different parts of the computation. Log-return comparisons avoid exponentials at monitoring dates [5], while quantum signal processing (QSP) and integration-based loading encode nonlinear payoffs directly into amplitudes [6, 7]. Fourier-series and arithmetic-free methods can avoid explicit payoff circuits for suitable integrands [8, 9]. Here we retain the digital payoff-angle interface of fixed arithmetic benchmarks and ask how its cost can be reduced while making both its coherent action and financial approximation assessable. A correct implementation of an integer function can still disagree with the real contract near a threshold; checking the intended arithmetic and quantifying that disagreement are separate obligations.
With constant model coefficients, uniform time steps and an equally spaced factor grid, the benchmark log-returns are affine functions of cumulative index sums. The factor-sum autocallable retains three 10-bit market-state counters and contract history, reconstructing weighted forms temporarily. TARF uses one index sum with accrual tracking and date-dependent lookups. These representations reduce persistent arithmetic state; for factor-sum, the retained state also supports compositional verification and a recombining numerical calculation of financial error. The main contributions are:
(Algorithmic) We use language-model-guided circuit search to develop compact payoff-arithmetic constructions that reduce the value of , where is the Toffoli-equivalent gate count and the peak live logical-qubit count, by 2.39-fold for the factor-sum autocallable circuit relative to the log-return reference, and by 4.84-fold for the windowed TARF circuit relative to the lookup reference (Sections 3 and § 4.2).
(Verification and financial error) For the factor-sum autocallable, we prove the coherent integer action for every encoded input, incoming accumulator and measurement record, including clean workspace and phase cancellation. Accumulator complementation supplies a logical inverse with unchanged Toffoli count and peak qubits. A separate lattice calculation gives a numerical probability of for exceeding the rad angle tolerance and evaluates pricing bias, with bounded omission but no certified numerical enclosure (Section 5).
(Experimental) At a second autocallable setting, the tested generic factor-sum transfer loses its advantage, while fresh bounded search finds shift-add and lookup lattice-form circuits with 1.35-fold and 1.31-fold lower products than the transferred reference. This establishes recovery at one further setting and exposes parameter dependence (§ 4.3).
Resource comparisons cover payoff arithmetic after loading and before payoff rotation, under matched tasks and precision targets. The all-input finance theorem applies to the factor-sum integer action; other finance circuits have the separately reported validation evidence. Search assistance and task-file access are described in § 4.1. The Harrow–Hassidim–Lloyd (HHL) angle task provides a separate calibration (Appendix § 9.5). Complete pricing implementations and general search reliability are outside the claims.
Related work
Our constructions combine measurement-uncomputed adders [10], unary-iteration lookups [11, 12] and piecewise-polynomial arithmetic [13]. Log-space tests and tables are established tools; the Q# reimplementation of published payoff operators also uses exponential lookup tables [14]. Published resource estimates count different operations and accuracy boundaries [6, 7, 14].
The design process follows the evaluator-guided program evolution of Gu et al. [15], related to AlphaEvolve [16]. Kickmix circuits admit classical checks of basis values, phases and measurement-based cleanup [17]; Khattar et al. [18] provide related benchmarks and an independent simulator. Other machine-assisted approaches optimize tensor decompositions, local rewrites and synthesis heuristics [19, 20, 21, 22]. Our evidence supports the reported constructions and their verification, without a comparative claim about the search method.
Problem definition and resource model
Derivative pricing evaluates the expected discounted cash flows generated by an underlying price path [4]. We study two fixed path-dependent benchmarks. (1) The autocallable can terminate on scheduled call dates; if it survives, a barrier breach can activate a terminal loss linked to the worst-performing asset. (2) The TARF accumulates signed payments and terminates at a knock-out barrier or an accrual target. Both contracts therefore require history as well as the current market state.
Discrete pricing problem
Each independent five-bit index selects a real grid midpoint with probability , defined by
These are normalized midpoint density weights, not Gaussian bin probabilities; no endpoint or tail outcomes are added. Reported calculations and samples use the frozen binary64 loading-probability vector. The appendices identify this vector and specify the separate normalization convention and allowance used by the lower-window crossing calculation. For dates and factors, write for the index at date and factor , and for the encoded path. Thus contains indices, whereas is a real grid value. Every date and factor uses , including in the second autocallable setting, so the loading law is
The values of fix the number of input qubits. For each encoded path, the dynamics and contract rules below determine an already discounted payoff . With , the computational target is
All payment discounting is included in . The relation between this finite benchmark value and a continuous or calibrated market model is outside the present arithmetic-error analysis.
The contract rules are transcribed from the frozen tasks and checked against independent high-precision references; Table 1 collects the benchmark parameters.
| Parameter | Autocallable: original | Autocallable: second | TARF |
| Factors | 3 | 3 | 1 |
| Dates | 20 | 20 | 26 |
| Time step | |||
| Rate | 0.02 | 0.02 | 0.02 |
| Volatility | (0.10, 0.25, 0.40) | (0.13, 0.22, 0.37) | 0.40 |
| Pairwise correlation | 0.50 | 0.35 | — |
| Input qubits | 300 | 300 | 130 |
Table 1. Benchmark parameters. All settings mature at one year and use five bits per factor index. Between the autocallable settings, only volatility and correlation change.
Three-asset worst-of autocallable
For asset indices , let , for , and be the Cholesky factor of the covariance matrix with entries . The cumulative log-returns and their minimum are
Initially , the contract is uncalled and no knock-in has occurred. Writing for asset ’s price, relative prices start at ; no absolute initial price is required. At dates , , the first with calls the contract. Monitoring at every sets the knock-in flag when . Calls take priority over the terminal put:
Let and . The normalization is . Both parameter settings use the same contract, grid, normalization and acceptance rules. These fixed benchmarks are not calibrated market models.
Target accrual redemption forward
For this single-factor task write . The underlying price starts at and evolves as
The contract starts alive, with undiscounted accrual and discounted payoff zero. At each date , test knock-out before payment: terminates without paying at that date. Otherwise the uncapped payment is
If , pay and terminate; otherwise pay , update and continue. Thus negative payments reduce accrual; they are not clipped to zero. Payments after termination are zero. With discount factors , the discounted payoff is . These comparisons include equality at the knock-out and cap, with strike equalities as in Eq. (7). We use the contract of Chakrabarti et al. [4] and their twenty-six-date resource benchmark; their algorithm example uses fifty-two dates.
Let and . We normalize as . Each date pays at least ; capped partial payment sums and decreasing discount factors bound the total above by . This is our declared normalization, distinct from the looser printed source bound.
Reversible payoff arithmetic and accuracy requirements
For either contract, write for its normalization constants above, so that and . The normalized expectation determines the benchmark value:
The digital-angle interface used in arithmetic-based pricing [4] takes as its target
The accuracy check compares against the unrounded real target . A circuit produces an integer increment ; rounding gives an ideal digital target, while the declared tolerance permits other increments. Both tasks require the coherent action
The incoming 22-bit accumulator is arbitrary. The path is preserved, workspace starts and ends at zero, and the corrected action must hold coherently on superpositions independently of measurement outcomes. For the factor-sum circuit, the coherent-output theorem below proves , its specified integer model, for every input, incoming accumulator and measurement record.
For any incoming accumulator, recover the increment as
Read the modular difference as an unsigned integer in . It must depend only on , independently of and corrected measurement outcomes.
For a circuit realizing Eq. (10), suppose the declared path law is loaded coherently and the angle accumulator starts at zero. An ideal rotation on a separate payoff flag initialized to would give
For the target angle , the flag-one probability is ; the computed angle instead defines the effective value . A valid arithmetic inverse can then clear the angle register without changing the flag probability. Amplitude estimation can estimate that probability [3, 4]. This describes the intended integration interface; the reported resource counts cover the arithmetic component.
The angle tolerance and allowed probability of exceeding it are distinct parameters:
The required population condition is
An angle-tolerance violation is this event under the discrete product law, called a “wrong output” in the finance records; it differs from bit-for-bit disagreement with a rounded angle word. Input modification, dirty ancillas and phase errors have no allowance.
Empirical screening and independent validation are described with the search protocol and verification results below.
Since , paths within tolerance have normalized-payoff error at most ; exceptional paths contribute at most their probability to expected error, as developed in the pricing-error analysis below. The per-path tolerance is numerically ten times smaller than the source’s payoff-precision budget [4]; their different definitions prevent interchanging them.
Resource objective and accounting
For each fixed contract, loading law and angle encoding, the design objective is to reduce subject to the coherent interface in Eq. (10) and the approximation target in Eq. (14). The search provides improved constructions against matched references, without establishing resource optimality.
For the metric , counts controlled-controlled-X (CCX), controlled-controlled-Z (CCZ) and controlled-SWAP (Fredkin) operations in Toffoli-equivalent units, and counts peak live logical qubits, including inputs, output and workspace, with reuse after clean freeing. We report both counts to expose tradeoffs. The component covers path arithmetic, contract decisions and digital angle computation after Gaussian loading and before payoff rotation; loading, the rotation ladder and Grover reflections are excluded. These counts are not compiled Clifford+, depth, runtime or physical-qubit estimates.
Circuit constructions
The constructions reduce arithmetic by choosing what to retain and what to reconstruct temporarily. Compact market state still requires contract history, and exact integer accumulation need not reproduce the real payoff. Figure 1 summarizes the separation. These are the resulting circuits, not a claim that every ingredient originated with the language model: authors supplied the tasks and controls, Claude proposed and implemented candidate designs, and deterministic tools fitted constants and evaluated programs. § 4.1 separates these roles and traces one retained design session.

Figure 1. Retained state and temporary arithmetic in the two finance constructions. Arrows show the datewise data flow; contract history persists alongside the index sums. Boxes denote arithmetic stages rather than primitive gates.
Autocallable construction
Log-return reference
The log-return reference retains one fixed-point log-return per asset, with 26 fractional bits and an offset placing the knock-in barrier at zero. A five-bit breach counter and records for the five call dates retain contract history. At each date, five-bit table lookups supply correlated increments and drift; these words are added to the asset registers and cleared by measurement-based unlookup. Sign tests update the breach counter, and three comparisons determine the call decision on call dates. The input registers remain available for reversal.
At maturity, a temporary worst-of calculation feeds a piecewise-linear put-angle table, fusing the exponential, normalization, square root and arcsine. Constant and first-call corrections complete the increment before a reverse sweep clears state and history. Log-return comparisons avoid per-date exponentials, but path increments still account for about 84% of Toffoli gates. Rounded increments can change near-threshold decisions, while the terminal table, products and finite range introduce further approximation (Section 5).
Factor-sum circuit
The factor-sum circuit replaces those rounded log-return registers with exact index sums . Let , and , so . Substitution in Eq. (4) expresses the real log-return as
Here and are the index coefficient and per-date constant in this exact affine identity. Constant coefficients and equally spaced dates make the three index sums sufficient for reconstructing the market state. Since , three ten-bit registers accumulate them without wrap. A five-bit knock-in counter and a two-bit counter for each call date retain the history; paths with the same sums can have different previous breaches or calls.
For the original parameters, , and . At each date , the circuit uses the integer forms with fixed integer coefficients , , :
These forms are integer combinations of the raw sums ; their coefficients approximate the asset ratios, while index accumulation remains exact. Here is distinct from the interest rate . Define the log-return scales , , and coefficient sums . For a real log-return threshold , the represented log-return approximations and corresponding integer thresholds are
The circuit compares integer forms directly: tests , while implements the strict comparison. Calls require all three assets to pass .
For knock-in at , one counter increment records an asset-1 or asset-2 breach at every date 1–20; a separate increment records asset-0 only at dates 12–20. Omitting asset-0 tests at dates 1–11 is a deliberate approximation: such a breach is missed unless another counted breach sets the history. The integer model and lattice analysis use this same schedule.
Because each decision needs only the threshold comparison, the date sweeps construct the integer forms temporarily without retaining additional log-return words. Signed digits express coefficients as shifted copies of the sum registers; negative digits use complemented copies and constant offsets. Column reduction [23] leaves sum bits as parities of existing qubits and allocates temporary qubits only for nonlinear carries, forming a virtual register. A constant makes the top carry the threshold decision. The asset-2 reduction reuses asset-1 parities, and measurement-based cleanup clears the carries after use.
For a local worked example, let , and be three existing two-bit registers, and consider . All six lowercase variables are bits in this example; denotes exclusive OR and Boolean AND. The bits occupy qubits; shifted copies are references to those qubits, not new registers. Reduce its columns as follows, with the majority bit:
| Column | Incoming bits | Sum bit (parity) | Carry to next column |
| 0 | none | ||
| 1 | |||
| 2 | |||
| 3 | none |
Table 18.
Then . Only and need new qubits; there is no allocated four-bit register. A required parity can be exposed on an existing qubit with controlled-NOT (CNOT) gates, used, and restored. The identity allows each generic carry to be computed with one Toffoli and Clifford gates. After the decision is used, the carries are cleared in reverse order by measurement. For measurement outcome , the induced phase is canceled by conditional Pauli on and conditional controlled- (CZ) on the exposed parities , , followed by restoration of those parities. Cleanup therefore preserves input superpositions without further Toffoli gates. The same reduction handles the circuit’s longer signed-digit forms.
At maturity, the three integer forms are materialized once and converted to a common log-return unit. Signed worst-of selection feeds a prefix-tree put-angle table with Booth product rows, reused from another search family; branch constants complete the angle increment. Clearing the terminal work and reversing the date sweep restores sums and history. Appendix § 8.§ 1 specifies the common-unit offsets, truncation, signed wrap, table fallback and row rounding of the frozen implementation.
Thirty persistent sum qubits replace the wide path registers. Virtual sum bits avoid intermediate words, share arithmetic between forms and permit carry cleanup without additional Toffoli gates, although temporary carries still set the date-stage peak. Relative to the log-return reference, the circuit uses 55% fewer Toffoli gates and 7% fewer peak qubits, giving a 2.39-fold smaller product. Figure 2 locates most of the reduction in the date sweeps. This saving accompanies approximation: and shift decision surfaces, in addition to the omitted early asset-0 tests. Terminal truncation, finite range, table fallback and product rounding introduce separate errors, including selected wrap failures. Section 5 separates exact implementation of these integer rules from their numerical financial error.

Figure 2. Toffoli accounting by forward dates, terminal payoff and reverse dates for each reference/final pair. Bars sum to the retained secure totals. These are implementation comparisons, not controlled ablations; Table 7 gives the combined detailed stage counts.
Fixed-point control
The fixed-procedure control uses a common gate template with three asset registers and contract history. Its generator crosses 24, 26 and 28 fractional bits with two local terminal-table fitting targets, and radians, producing six configurations. It computes and rounds Cholesky coefficients, derives full-range signed widths, and fits/subdivides terminal linear-table cells; the local fit target is not a total circuit-error guarantee. The generator/template were AI-assisted, but their execution makes no model queries or architectural revisions from scores. A predeclared rule chose the lowest gate–qubit product among structurally valid empirical screening passes, breaking ties by qubits then identifier. Two lower-precision variants failed screening; the selected control uses 19,074 Toffoli gates and 610 qubits, more than the log-return reference. Its full-range arithmetic and fused terminal table provide a comparison without shared integer forms, not an optimality claim; coefficient, finite-width and terminal approximations remain. Appendix § 8.2 gives the configurations and selection details.
TARF construction
For TARF, define the raw index sum , drift coefficient and index coefficient . The grid then gives . The TARF lookup reference retains , remaining cap room, a discounted-payoff accumulator and progress/cap records. Each date looks up the payment and its discounted value, tests knock-out before payment, and updates accrual and termination history. Lookup words and comparison workspace are cleared. A single cap-date correction and fused terminal angle table complete the payoff before reversal. Tabulation avoids the coherent exponential used by the TARF price-space reconstruction, while streaming avoids storing every payment. The two implementations share cap/termination history and cleanup; their resource comparison is not a controlled ablation or a published complete-pricing comparison.
The windowed TARF circuit narrows the lookup address and arithmetic words of the TARF lookup reference. Its accrual representation follows an exact real-arithmetic identity. Let be the full uncapped payment at each reached paying date, zero on a knock-out date and after termination, and define and . Unlike the running accrual in Section 2, includes the full cap-date payment before clipping. If the cap is reached at , the excess is subtracted from that payment, giving
Without a cap, including knock-out termination, . Since and , . Thus the circuit can retain shifted accrual and the narrow discount correction , rather than a wide discounted total, and apply one cap-date product.
With this representation, the windowed TARF circuit retains seven cyclic index bits over a date-dependent window, finite-precision and words with fixed implementation offsets, and alive/stop-date records. A prefix-tree lookup supplies payment, discount correction and a knock-out bit for lumped high-index leaves, replacing the separate knock-out comparator. The updated sign tests the cap. Lookup-output qubits are measured and reset; their phase corrections combine with reverse unlookup after the date address and controls are restored (Appendix § 8.4). Encoded stop dates simplify reversal, and adders use the top carry directly. After the loop, a Booth-recoded cap product and in-place integer square root feed a piecewise-linear angle table whose product rows subtract into . Narrow date words and this terminal arithmetic account for the smaller stages in Figure 2; its gate–qubit product is 4.84 times lower than the TARF lookup reference.
Two approximation mechanisms must be distinguished. First, excluding a prescribed lower window leaves at most 121 pre-knock-out indices per date, allowing seven address bits and merged don’t-care lookup leaves. An excluded path can reach these addresses and alias a different payment or stop decision. The independent lower-window calculation bounds a conservative crossing event, not total circuit failure (Appendix § 10.2).
Second, finite-precision accrual and payment arithmetic can change the cap date even inside the retained window. The accrual word has 15 fractional bits, with coarser payment rounding later; independently rounded table words, dropped product bits, finite widths and the angle table need not preserve the real cap identity. The lookup reference also rounds payments and discount products and has selected cap-tie failures. These effects are separate from lower-window aliasing. Appendix § 10 relates the selected failures to the crossing bound and cap-tie analysis; the latter remains conditional on an unproved rounding relationship.
Second parameter setting
The original coefficient specialization does not transfer directly when volatilities and correlation change: its compact ratios are lost, and the tested generic factor-sum transfer has 5.58 times the gate–qubit product of the transferred log-return reference. Fresh search instead produced two lattice-form circuits. For fixed integer weights , write their mathematical forms as . Their registers retain these weighted forms with date-dependent offsets, plus knock-in and call history. They accumulate the weighted forms directly; separate raw-sum registers are not retained.
The shift-add lattice-form circuit packs same-sign shifted index terms into shared adder words. The lookup lattice-form circuit supplies factor-0 and factor-1 increments through two 32-entry tables and uses shifted additions for factor 2; its tables also carry drift and threshold changes. Neither uses virtual registers. Both temporarily convert the terminal forms to a common unit, select the worst asset and evaluate a short piecewise-polynomial put angle, then clear that stage and reverse the dates. Their gate–qubit products are 1.35 and 1.31 times lower, respectively, than the transferred log-return reference. The fitted weights and thresholds are specific to this setting. Exact integer updates do not exclude rare decision errors, terminal rescaling and finite-range errors or polynomial/product approximation; selected tail failures remain. Appendix § 8.3 gives these setting-specific weights, fitting rules and terminal conversion conventions; § 4.3 interprets the transfer comparison.
Search protocol and resource results
The previous section presented the circuit constructions for the two pricing benchmarks, highlighting how compact state representations, temporary arithmetic and tailored lookup operations reduce the cost of reversible payoff evaluation. We now examine how these constructions were developed through language-model-assisted search and quantify their resource savings. § 4.1 describes the design workflow, including the respective roles of the researchers, language model and deterministic evaluation tools. § 4.2 compares the resulting circuits against matched internal references, while § 4.3 examines how the designs behave when market parameters change.
Evaluator, search, and provenance
Design workflow and attribution
Following Gu et al. [15], we separate architecture proposals, executable design and evaluation (Figure 3). The authors fix the contract, interface, accuracy and resource rules, permitted access and search budget. In the later budgeted runs, an ideation session supplies Claude with the task specification, builder API and instructions to propose up to four distinct architectures, describing retained state, arithmetic, uncomputation and expected cost, without yet writing a circuit. General design principles are also in the system prompt. Permitted task/model code can expose useful identities; proposals therefore need not originate independently of that information. Ideation returns named family descriptions for subsequent design sessions.

Figure 3. Roles and information flow in our evaluator-guided design process, following the organization of Gu et al. [15]. The feedback loop is within development; final evidence is separate. Access, assistance and reuse vary by run (Appendix § 11); family labels do not imply independent implementations. § 4.1 traces the second-setting lookup circuit through this workflow.
A design prompt supplies a founding family and, where allowed, parent/inspiration programs and previous feedback. Claude writes a Python build(b, regs) program, coefficient data and any fitting or emulator helpers. Executing the builder calls deterministically emits a fixed gate tape; it does not translate prose automatically or branch classically on a sampled path. The helpers perform numerical work, whereas Claude chooses and revises their code and the circuit structure in response to development counts, errors or counterexamples. Interactive references and fixed-procedure controls were prepared separately. The separate-process scorer validates and serializes a submitted tape, recounts resources and simulates basis values, phases and measurement corrections; its archived results supply the reported resource counts. Process separation is not an operating-system sandbox. Later frozen-candidate studies and proofs supply their own evidence, rather than feeding the completed search.
Illustrative search trajectory
One retained example is the second-setting lookup lattice-form circuit (§ 3.3). Ideation returned three families; its F1 proposal combined fitted per-asset integer forms with per-factor lookups. Starting from a blank candidate, Claude wrote the circuit, a lattice fitter and an emulator. Development failures exposed a fitter error: a threshold had been allowed to split equal integer-form values. Claude corrected the scoring and refitted asset 2, replacing an own-factor weight of 1993 by 11932; the final form is . The submitted circuit uses two 32-entry lookups and factor-2 shift-adds. Its separate-process score is 13,661 Toffolis and 524 qubits, a 1.31-fold product saving against the transferred log-return reference; it passed empirical screening. The audit records no human repairs in this session. This is a recorded within-session refinement, not an all-input accuracy argument; selected tail failures remain.
Evaluation protocol and provenance
For completed trajectories, let count angle-tolerance violations and , and count input, workspace and phase failures. The scorer accepts empirically when
All requested tests must complete and the gate tape must also be valid. Standard screening at permits one angle-tolerance violation. We call this passed empirical screening; the acceptance rule is not a population confidence guarantee for Eq. (14). Passed held-out validation refers to separate fresh studies of frozen candidates, with sample sizes, references, outcomes and confidence bounds reported in Section 5.
The authors identify the search model as Claude Opus 5.5; exact early model identifiers are unavailable. The assisted, full-repository autocallable and HHL searches retained four and five programs without predeclared stopping budgets; the best HHL brief included hand-written hints. TARF completed seven budgeted sessions (ideation, four designs, two rewrites) in a sanitized workspace, but all six programs share one lineage and four design sessions read the task model containing the index-sum identity. At the second setting, one ideation and three one-iteration design trials, capped at 90 minutes and 100 turns, produced two circuits; permitted model/task files remained accessible. These latter searches received no additional run-specific design hints. Access, assistance and the small number of trials limit attribution and repeated-search reliability. Appendix § 11 summarizes provenance and availability; the versioned artifact retains the full audit metadata and protocol amendments.
Matched internal resource results
Table 2 gives the headline secure counts. To express a saving against the reference named in each block, define
| Circuit | |||
| Autocallable; reference: log-return reference | |||
| Log-return reference | 16,810 | 556 | 1.00 |
| Factor-sum circuit | 7,551 | 518 | 2.39 |
| TARF representation; reference: price-space reconstruction | |||
| Price-space reconstruction | 3,334,652 | 653 | 1.00 |
| Lookup reference | 28,428 | 384 | 199.5 |
| TARF search; reference: lookup reference | |||
| Windowed TARF circuit | 8,381 | 269 | 4.84 |
| Second setting; reference: transferred log-return reference | |||
| Transferred log-return reference | 16,810 | 556 | 1.00 |
| Generic factor-sum transfer | 81,552 | 640 | 0.179 |
| Shift-add lattice-form circuit | 12,685 | 547 | 1.35 |
| Lookup lattice-form circuit | 13,661 | 524 | 1.31 |
Table 2. Secure payoff-arithmetic counts and rounded ratios. Each block names the reference in Eq. (20); the two TARF comparisons have different denominators. These component ratios do not establish complete-pricing advantage.
Thus means lower candidate product and higher product. Table 3 separates resource results from their evidence.
| Circuit(s) | Sampled validation | Proof and distribution analysis |
| Factor-sum autocallable | Million-path task holdout and independent-reference study | Coherent integer action proved; numerical lattice analysis without certified enclosure. |
| Log-return reference | Million-path task holdout and independent-reference study | Partial structural result; cleanup open. No integer-output proof or distribution analysis. |
| TARF lookup reference | Million-path task holdout; independent high precision on selected inputs only | Partial structural result; cleanup open. No integer-output proof or unconditional distribution analysis. |
| Windowed TARF circuit | Million-path task holdout and independent-reference study | No all-input proof. Conservative lower-window event bound only, not total failure probability. |
| Original fixed-point control; all five second-setting circuits | Million-path task holdout and independent-reference study for each | No all-input structural/output proof or distribution analysis. |
| TARF price-space reconstruction; three other autocallable families; five earlier TARF programs | 100k empirical screening only | No independent high-precision study, all-input proof or distribution analysis. |
Table 3. Finance evidence summary; grouped rows share status, not pooled samples. Million-path task-reference and independent-reference studies remain separate. Populations and confidence/multiplicity methods are in Appendix § 9.§ 1.
Among the autocallable circuits plotted in Figure 4a, the factor-sum circuit has the lowest product, while the screening-only two-form-basis candidate (F4-001-01cb) uses fewer qubits at a slightly higher product. The fixed-point control lies above the log-return reference, so conventional fixed-point rounding did not reproduce the saving in this comparison. All four search families reduce cost, but three have only screening evidence; their position on the resource frontier does not establish accuracy.

Figure 4. Finance resource tradeoffs for the named comparisons. Arrows label from Eq. (20); Table 2 identifies every denominator. Teal search circles use the E/V key above; larger filled circles mark minimum-product programs. Squares denote references/fixed transfers and triangles controls/reconstructions, with other statuses in superscripts. Dashed curves have equal ; the thin frontier ranks resources, not accuracy. Figure 7 gives the separate HHL calibration.
The two TARF displacements in Figure 4b answer different questions. Replacing price reconstruction by payment lookup gives the large representation saving; narrowing the state and terminal arithmetic then improves that lookup reference. The six related search programs trace refinement of one lineage. Only the final windowed TARF circuit received the predeclared million-path holdout and later independent-reference study; the earlier points remain screening-only, including one with an allowed violation. Resource improvement along this lineage is not evidence of six independent successful searches.
Parameter transfer and comparison scope
At the second setting, the tested fixed adaptation loses its resource advantage (Figure 4c), while fresh fitted-form designs recover smaller savings than at the original setting. The shift-add lattice-form circuit favors fewer gates and the lookup lattice-form circuit fewer qubits. This comparison changes both parameters and implementation, so it does not isolate the cause of the fixed transfer’s loss. Separate million-path validation supports both fresh circuits (Section 5); one additional setting does not establish general transfer, repeated-search reliability or scaling. Table sizes and coefficient structure can alter the tradeoff as precision, dates or assets change.
Published resource estimates [6, 7, 14] count different operations and accuracy boundaries. In particular, QSP can combine payoff evaluation with amplitude encoding, while our component writes a digital angle. The matched internal comparisons are the primary resource evidence; a complete-pricing comparison requires an integrated construction.
Search circles: hollow = empirical screening only (E); filled = held-out validation (V).
Verification and pricing error
The resource comparisons establish that the proposed constructions can substantially reduce payoff-arithmetic costs, but resource efficiency alone does not establish correctness or pricing accuracy. In particular, the use of compact integer representations, finite-precision arithmetic and truncated lookup ranges introduces potential discrepancies between the implemented payoff angle and the financial contract. Moreover, empirical screening of candidate circuits does not guarantee correct coherent behavior on all inputs. In this section, we provide the verification and error analysis, where we distinguish exact implementation of the specified integer arithmetic from numerical agreement with the underlying financial payoff.
Figure Figure 5 maps the evidence from the frozen tape to logical action, financial error and statistical bounds on specified populations.

Figure 5. Evidence routes for the factor-sum circuit. The numerical and statistical routes use the implemented loading law; the logical proof covers every encoded input and incoming accumulator with clean workspace. The inverse has this same logical scope; controlled use and a complete pricing implementation remain outside the result.
Exact logical action and inverse
Let be the frozen tape from the archived factor-sum program F3-001-ccd3: 259,386 operations, 518 qubit slots and measurements. The map is defined by the integer arithmetic and table interpretation in Appendix § 8.§ 1 together with the fixed 292-quadruple coefficient dataset identified by the artifact manifest. Equation (33) defines the modular increment. This is the model used in the financial-error calculation, with the omitted early asset-0 tests retained.
The semantics are those of the evaluator: , CNOT, Toffoli, SWAP and Fredkin act as reversible Boolean gates; , , and global signs supply phases . Only these diagonal operations may be conditioned on the XOR of earlier measurement bits. Allocation supplies ; freeing is permitted only at zero. The sole measurement primitive, hmr, destructively measures an ancilla in the basis and resets it to ; interface qubits are never measured. These ideal semantics, including the measurement corrections, define the theorem’s scope. Write for the clean-workspace modular-addition operator specified below.
Theorem 1 (Coherent integer action of the factor-sum tape) For every and every , with workspace initialized to zero, the corrected implementation of under the stated semantics realizes
Every input is preserved, every workspace qubit is restored to zero before release, and both unconditioned and measurement-dependent phases cancel. The action holds coherently on arbitrary superpositions, including inputs entangled with an external register. For each complete measurement record , its branch operator on the initialized input subspace is . Consequently the record is uniformly distributed and independent of the input state, and discarding it leaves the same coherent action.
The proof cuts the tape between dates, where only three ten-bit index sums, the knock-in counter and call counters persist. Reconstructed asset words have been cleared. Support checks establish that segment outputs depend only on declared cut-point inputs. Exhaustive bitsliced evaluation proves the finite-domain value claims; canonical XOR–AND cancellation proves that other live slots are unchanged and internal frees are clean. Each update maps its declared input range into the next segment’s domain, so the local claims compose from zero initialization. The terminal proof covers the entire signed worst-of range and its flag patterns. Eight accumulator-adder ranges are proved for every operand and incoming accumulator; their addends sum to , and a syntactic check excludes other writes to . Appendix § 9.3 gives the domains and full lemma inventory.
Restoration composes from the terminal block outwards: it preserves every live register except for arbitrary cut-point values, and each forward date paired with its reverse restores its live registers and clears its temporaries. The resulting sweep returns the initially zero workspace to zero before release. Phase obligations close by canonical cancellation or unsatisfiability certificates accepted by the independent DRAT checker. Only diagonal gates have measurement conditions, so basis values are record-independent and the sign splits into an unconditioned Boolean function plus one coefficient per measurement bit; all vanish.
For a measured basis bit and outcome , hmr resets the qubit and contributes . The value proof gives the same final permutation for every record and the phase proof cancels every sign. Multiplying the factors gives the theorem’s branch identity . By linearity it holds on superpositions and inputs entangled with an external register: the classical record is uniform and input-independent, and discarding it preserves coherence. Basis-value agreement alone would not establish this conclusion.
The trusted infrastructure comprises mirrored gate semantics, the integer model, canonical symbolic and bitsliced evaluators, Python/NumPy, the structural Tseitin encoding and independent DRAT checker, and tape segmentation asserted against the secure tape. This is a computational certificate, not a proof-assistant formalization. It proves the specified integer action, with its known financial approximation errors.
For an -bit accumulator with , define , implemented by on every accumulator bit and the identity elsewhere. In the inverse statement, denotes the data input: the encoded path for factor-sum or the input for HHL, whose integer increment is written .
Corollary 2 (Logical inverse by accumulator complementation) On the logical-data subspace with clean workspace, the additive action of Theorem 1, and the HHL action proved in Section B.5.2, satisfy
Here for the factor-sum circuit; for HHL, and on its specified input domain.
The arithmetic identity proves the inverse for every allowed input and accumulator on clean workspace. Each corrected wrapped branch is with the ordinary forward measurement corrections and fresh, input-independent records. It does not reverse a measurement history or act as an adjoint gate list on arbitrary workspace. The factor-sum wrapper retains 7,551 Toffolis and 518 peak qubits, adding 44 gates. Appendix § 9.§ 4.2 summarizes the recounts and bounded composition checks; the all-input result comes from the algebra and theorem, while replay checks the wrapper implementation.
As a calibration, HHL also has an exact additive logical-action proof and inverse. Its twelve exact logical lemmas are separate from the exhaustive 45-digit numerical accuracy comparison, which finds error below rad without a certified transcendental-reference enclosure. The complete construction, proof inventory, numerical result and inverse (including 66 added gates) are in Appendix § 9.5.
Numerical financial error from the lattice
The probability evaluated for the proved integer map is
Write for the raw index-sum vector and for one of its values. Both the integer model’s and financial target’s datewise tests depend on . Before either side calls, denotes active probability mass after date , with binary knock-in flags for the financial target and for the integer model. Initially and all other masses vanish. Writing a superscript for mass before the date- tests, the uncropped index transition is
This convolution advances the raw index sums; the barrier tests then update the two knock-in flags. The financial target monitors every asset at every date; the integer model tests assets 1/2 throughout and asset 0 only from date 12. At call dates, mass where either side calls moves to absorbing agreement/disagreement states. A call on one side only is always a tolerance violation, since its value is separated from every remaining outcome of the other side. At maturity the remaining mass is classified by evaluating the full integer terminal arithmetic, including wrap and table behavior, against the financial angle. The rounded log-return reference circuit accumulates rounded per-index increments and does not recombine on ; this recursion does not apply to it.
The retained numerical calculation gives under the implemented loading law, with accumulated omitted mass bounded by . Although the recurrence is exact in real arithmetic, its propagation, target-angle evaluation, classifications and final sums are numerical. The omission bound does not cover roundoff or transcendental evaluation, and no outward-rounded certified numerical enclosure is available. Figure 6 compares the full-output and decision-only calculations with Monte Carlo and the sampled upper bound, and shows the dominant mechanisms. Appendix § 9.§ 4.3 explains the omission treatment, margins and cross-checks; the artifact manifest indexes the full numerical records.

Figure 6. Factor-sum angle-tolerance violations under . (a) Filled points: numerical lattice values, with omitted mass bounded by but no certified numerical enclosure. Hollow points/bars: independent full-output () and decision-only () Monte Carlo estimates with 95% intervals; arrows mark the single-circuit 95% zero-in- bound and task budget. (b) Lattice values by mechanism. Numerical records are in Appendix § 9.§ 4.3.
Independent validation and selected failures
The validation population is the product loading law, a uniform 22-bit incoming accumulator and the evaluator’s measurement outcomes, unless a theorem removes a dependence. Theorem 1 reduces the factor-sum violation event to the path law alone. For other finance circuits, sampled success does not guarantee every accumulator or measurement record. Angle-tolerance violations, input modifications, phases and workspace failures are separate statistics.
Factor-sum and the log-return reference each have zero violations in a million-path independent 60/90-digit study and a separate million-path task-reference holdout. The fixed-point control and all five second-setting circuits have the same zero-violation outcomes in individually retained studies against both references. Their populations and declared comparison families remain separate; retained fixed-design samples are reused in the second-setting comparison, not redrawn or pooled. The TARF lookup reference has a million-path task-reference holdout, with independent high-precision checks only on selected inputs. Windowed TARF has separate million-path task-reference and independent 60/90-digit holdouts, both with zero violations; the independent-reference study used every sampled path at both precisions. Precision agreement checks numerical consistency, not a certified reference-error enclosure. Sampled structural errors were zero in the final studies, without establishing an all-input TARF structural proof.
For one circuit fixed before independent draws and significance level , zero violations gives the one-sided upper bound at confidence . At 95%, zero in gives , whereas zero in gives approximately and does not establish the task’s population target. The windowed TARF independent-reference result uses the single-circuit bound, conditional on its numerical reference, without pooling with earlier samples. Appendix § 9.§ 1 gives all declared multiplicity adjustments; Appendix § 9.§ 4.1 summarizes that study’s reference, population and outcomes. Screening records, including the TARF price-space reconstruction and the additional family points, remain screening evidence.
Independent-simulator replays for factor-sum and windowed TARF give bit-for-bit agreement on one million inputs each using the same task model; they cross-check simulation, not the financial reference. Selected counterexamples serve another purpose: coefficient rounding and omitted early asset-0 tests can change decisions, while finite terminal words can wrap and become a false worst asset. TARF lower-window addresses can alias different payments, and finite-precision cap decisions can change termination even inside the retained window. These deliberately chosen populations do not estimate loading-law failure probabilities. Appendix § 9.2 retains fixture construction and category counts, and Appendix § 10 gives TARF mechanisms and qualified exceptional-event calculations.
Pricing error and integration
The values in Eqs. (8) and (12) satisfy . Thus normalized-payoff bias translates directly into contract units.
For a fixed computed path angle , define the effective normalized payoff . The derivative bound gives
On the complement of the angle-tolerance violation event, the payoff error is at most ; on that event it is at most one. For its actual probability under ,
This analytical inequality uses the actual probability; is a target upper bound, not an observed value. For factor-sum the theorem supplies the fixed path-angle function .
Using a single fixed-circuit, zero-in- independent-reference study gives a normalized-bias upper bound of about at one-sided 95% confidence, conditional on the reference; this confidence comes from the sample. Substituting instead gives approximately as a numerical evaluation of the analytical bound, subject to the lattice qualifications above, without a certified numerical endpoint or statistical confidence interpretation. For the original autocallable task, contract-unit bounds multiply by from Section 2; the affine shift cancels.
The numerical lattice value of the signed bias is in normalized units, or contract units. Its allowance covers omitted and call-disagreement mass but not all numerical error. The reported log-return-reference sample mean is in normalized units from paths, approximately twice the lattice magnitude; rare-event uncertainty in that reference sample is unresolved, so it compares reported estimates, not an established ratio of population biases. Appendix § 9.6 gives the interval diagnostic (Figure 8) and summarizes the zero-accumulator replay.

Figure 8. Factor-sum signed price bias. Filled point/line: numerical lattice value with bounded omission, without a certified enclosure. Hollow points/bars: sample means and nominal 95% normal-approximation intervals; the million-path interval misses the lattice value. Coverage is not established.
These results concern the arithmetic component and its effective payoff. A complete pricing construction must add Gaussian loading, payoff rotations, reflections and any controlled use required by a specified amplitude-estimation variant, with discretization, market-model, synthesis and estimation errors budgeted separately. Corollary 2 supplies the logical inverse with unchanged Toffoli count and peak qubits; controlled use and correctness/compiled costs of the complete construction remain unresolved. Hardware decomposition, scheduling, measurement/feed-forward and error correction can change the resource tradeoff; qubit reuse is already counted.
Discussion and conclusion
Compact retained state helps both circuit cost and verification because it limits what must be updated, reconstructed and restored. The factor-sum circuit stores the raw index sums and contract history, constructing weighted integer forms only when needed; the small state between dates supports a compositional proof and a recombining calculation of financial error. The proof identifies the coherent integer action exactly, while the lattice evaluates its financial approximation numerically, with bounded omission and no certified numerical enclosure. These benefits depend on the complete retained state: TARF also carries path-dependent accrual and discount-correction words, so recombination of its market index alone does not determine its full error probability. Stage profiles locate the cost differences between implementations without isolating individual optimizations as controlled ablations (Figure 2).
At the second parameter setting, fresh fitted-form circuits recover smaller savings after the tested generic factor-sum transfer loses its advantage (§ 4.3). Because parameters and implementation change together, this comparison does not isolate the cause. One additional setting and three design trials demonstrate constructions there, without establishing general transfer or scaling with dates, assets or precision. The search record also limits attribution: the original autocallable and HHL runs were assisted, the TARF programs share one lineage, and permitted task files exposed the index-sum identity. Documented access, missing early model identifiers and protocol deviations remain part of the evidence (Appendix § 11). These runs describe how the circuits were obtained; repeated comparisons under matched budgets would be needed to assess search reliability or performance against other design procedures.
The demonstrated result remains a payoff-arithmetic component with financial approximation error. Selected finance inputs still violate tolerance, and the other finance circuits do not inherit the factor-sum theorem. TARF’s independent-reference holdout supplies statistical evidence; its conservative lower-window crossing bound and conditional captie implication do not establish a total circuit-failure bound (Appendix § 10). Accumulator complementation supplies logical inverses for the proved additive actions, but controlled use, where required, and the complete loading, rotation, reflection and estimation construction remain unresolved (§ 5.4). A complete pricing comparison must align the loading law, accuracy budget, computational interface and compiled gate, workspace and feed-forward accounting. Published estimates [6, 7, 14] use unmatched boundaries, and amplitude-encoding approaches can avoid digital-angle arithmetic.
Compact integer representations yield lower-cost payoff-arithmetic circuits against matched internal references and, for the factor-sum circuit, connect a proved coherent integer action to a numerical financial-error calculation. This makes representation a useful part of designing quantum components whose resource savings and approximation behavior can be assessed together.
Author contributions and AI use
Monit Sharma and Hoong Chuin Lau directed the work and reviewed the results and claims. Claude assisted circuit and program design, software implementation, verification and numerical-analysis code. The circuit-search attribution and limits of the historical model identifiers are recorded in Appendix § 11. The authors take responsibility for the content and its claims.
Integer models and arithmetic details
Factor-sum integer model
The rules below specify the arithmetic and table interpretation for in Theorem 1; the frozen factor-sum coefficient dataset identified by the artifact supplies its 292 indexed quadruples. Inputs are , , . Operations are integer except for the documented generation of fixed data. The literal thresholds, constants and frozen coefficients are authoritative; the generation formulas do not replace them with recomputed values.
1. State, initialization and date updates. Initialize three ten-bit sums , a five-bit breach counter (the proof’s ), and five two-bit call counters (the proof’s ), , for dates . At each date first update
These additions do not wrap. Define the temporary forms
With , . Forms are temporary arithmetic expressions, not additional state retained between dates. Every date is processed, even after a call flag is set; the final output gives priority to the earliest call.
Fixed thresholds and constants
The literal thresholds in Table 4 and constants below define the frozen rules:
| 1 | -35 | 6510 | 302833 | — | — | — |
| 2 | -20 | 181585 | 921725 | — | — | — |
| 3 | -4 | 356660 | 1540617 | — | — | — |
| 4 | 11 | 531735 | 2159509 | 76 | 745344 | 2560025 |
| 5 | 26 | 706810 | 2778401 | — | — | — |
| 6 | 42 | 881885 | 3397293 | — | — | — |
| 7 | 57 | 1056959 | 4016184 | — | — | — |
| 8 | 73 | 1232034 | 4635076 | 137 | 1445643 | 5035592 |
| 9 | 88 | 1407109 | 5253968 | — | — | — |
| 10 | 103 | 1582184 | 5872860 | — | — | — |
| 11 | 119 | 1757259 | 6491752 | — | — | — |
| 12 | 134 | 1932334 | 7110644 | 199 | 2145942 | 7511160 |
| 13 | 150 | 2107408 | 7729536 | — | — | — |
| 14 | 165 | 2282483 | 8348428 | — | — | — |
| 15 | 180 | 2457558 | 8967319 | — | — | — |
| 16 | 196 | 2632633 | 9586211 | 260 | 2846242 | 9986728 |
| 17 | 211 | 2807708 | 10205103 | — | — | — |
| 18 | 227 | 2982783 | 10823995 | — | — | — |
| 19 | 242 | 3157857 | 11442887 | — | — | — |
| 20 | 257 | 3332932 | 12061779 | 322 | 3546541 | 12462295 |
Table 4. Literal integer thresholds of the frozen factor-sum model. Every date uses the asset-1/2 barrier columns; asset 0 is tested only from date 12. Call columns are used only at the five call dates. The other call-threshold entries are unused and shown as dashes.
Thresholds and were generated with ceiling; offsets and angle words use numerical nearest-integer rounding with ties to even. The zero-payoff angle word is not zero. For the fitted target below, write , and , using the original step Cholesky factor of Eq. (4). The dataset retains the binary64 constants; its documentation gives their generation derivations. No recomputation replaces these literal integers or the fixed common-unit multipliers in Eq. (30).
Monitoring and call history
After updating the sums, set
Asset-1/2 breaches count once jointly per date; asset 0 counts separately only at dates 12–20. Its omitted tests at dates 1–11 are a deliberate approximation to the contract, not a claim that early breaches are impossible. At date , update the initially zero counter to
Other call counters remain unchanged. Breaches are strict, calls include equality, and the bounded history counters do not wrap. At maturity the knock-in flag is and the five-bit call pattern is ; these flags are derived from the retained counters.
Terminal words and signed wrap.
Using the final sums and forms, compute
Equivalently, . Dropping four low bits means floor division, including for negative values; it is not rounding toward zero or nearest rounding. The words are interpreted as signed two’s-complement integers before taking the minimum. Large terminal values wrap, rather than saturating or being clipped. A wrapped word can become the false worst asset, as in the retained counterexamples.
Put address, table data and fallback.
The put branch is eligible only if , and ; the last comparison is strict. Its unsigned address is . The fixed table has 292 disjoint prefix cells, each stored as a quadruple with depth , prefix , intercept and nonnegative slope word . It selects when
The cells here cover . Addresses outside the covered cells return even when the put branch is eligible: there is no extrapolation or clipping to an endpoint. The stored intercepts lie in , slopes in . The circuit packs the low 21 bits as and the upper 14 bits as , to XOR the put correction into the initially loaded no-call angle word. The mathematical definition below uses the resulting intercept directly.
Table target and numerical fit.
Let , not the offset from the selected cell’s left endpoint. The fitted target was
where is the normalization denominator defined in Section 2. The 7.5 is the midpoint of the sixteen values discarded from a terminal word. This target explains the coefficients; it is not substituted for their integer evaluation.
The fit evaluates every integer address in a cell using the implemented rounded row sum of Eq. (32), rather than an ideal real product. Its numerical acceptance criterion is not a certified contract-error bound. The frozen array determines the implemented function independently of refitting; the artifact documentation retains the complete slope search, subdivision, tie-breaks and generation procedure.
7. Rounded rows and output accumulation. Write for bit of , with outside . For a covered address set
Each nonnegative magnitude is rounded to nearest with ties upward, then its sign is applied. Thus negative ties round away from zero; there is no single rounding of the complete signed product. The seven rows, including the final digit for the unsigned 12-bit offset, are added modulo . Define on uncovered addresses. Finally,
No further rounding, saturation or signed-residue adjustment is applied. The definition holds for every starting accumulator; it is the additive integer action proved by Theorem 1, not the real contract payoff.
Autocallable: fixed-point control
Table 5 retains the six configurations and development outcomes. The generator made no model queries. Predeclared selection minimizes among structurally valid secure-screening passes, breaking ties by qubits then identifier; it selects STD-004.
| Variant | Fractional bits | Table target | Violations | Accepted |
| STD-001 | 24 | 615 | — | |
| STD-002 | 24 | 976 | — | |
| STD-003 | 26 | 0 | 12,513,540 | |
| STD-004 | 26 | 0 | 11,635,140 | |
| STD-005 | 28 | 0 | 13,044,416 | |
| STD-006 | 28 | 0 | 12,156,144 |
Table 5. Fixed-point configurations and retained development results. The local table target is a fitting target in radians, not a bound on total circuit error. Counts are angle-tolerance violations among 100,000 development trajectories; screening is not a population guarantee. The selected row is bold.
Second-setting parameters and implementation conventions
Table 6 gives the weights for the second setting in Table 1. Barrier thresholds enter date-dependent offsets and sign-bit tests; call dates use shifted thresholds. Threshold fits separate distinct form values so that tied states receive the same decision.
| Shift-add lattice-form circuit | Lookup lattice-form circuit | |
| Asset-1 weights (, ) | 751, 2010 | 34, 91 |
| Asset-2 weights (, , ) | 4469, 3101, 11552 | 4616, 3203, 11932 |
| Mixing at each date | Signed-digit shifted additions, packed into shared adder words | Two 32-entry lookups for factors 0 and 1; shifted additions for factor 2 |
| Knock-in test | Sign bit of a register offset by the threshold | Sign bit; threshold changes carried in the lookup words |
| Put angle | Piecewise-linear table with an 8-bit address | Quadratic on 128 segments |
Table 6. Second-setting integer forms , with . The circuits retain the weighted forms with date-dependent offsets, not separate raw-sum registers. Asset 0 has weight one on in both. Selected-tail outcomes are in Appendix § 9.2.
Fitting and terminal conversion. Convolution of the loading weights assigns mass to index-sum lattice points for numerical fitting. The shift-add fit uses simultaneous approximation with a shared denominator per asset; the asset-2 denominator is near . The lookup fit uses points within 0.003 of the log-return threshold with marginal and joint masses above . It chooses a separating threshold when possible, otherwise minimizing misclassified mass over the retained distinct form values. These design objectives give neither an all-input guarantee nor a complete circuit-failure bound.
For shift-add conversion, let and . The factors and use 9 and 19 fractional bits, with rounded drift/centering constants and restored threshold offsets. Multiplication retains four guard bits below the common asset-2 unit before signed minimum selection; the terminal table is piecewise linear with an eight-bit address.
For lookup conversion, use regression scales on the nonzero row coefficients, and terminal offsets . After restoring threshold offsets, convert the first two forms to the common unit by . Signed-digit multipliers use fractional bits, with register widths . Fixed rounded offsets compensate right-shift losses; the common word has 22 bits. The 128-segment quadratic angle table has three output guard bits and four extra curvature bits. These are finite-range, numerically fitted conventions, not a certified transcendental approximation.
Deferred measurement-phase corrections
Destructive -basis measurement of a lookup word , with outcome , resets its qubits and leaves . Delayed cancellation requires the same address and controls . For each fixed record of other measurements, the complete intervening block must preserve those data on the loaded-data subspace:
so for the complete block, without gate-by-gate commutation. Under a temporary permutation , the phase is ; restoring the original data restores the correction. Unrestored addresses or changed controls invalidate the argument.
HHL. The early constant-word phase depends on the original . Before final unlookup, the product block restores the coefficient word and undoes the low-input normalization, restoring that address. Saved constant-word outcomes combine with the remaining word measurements. The complete block preserves ; Appendix § 9.§ 5.2 gives the structural check.
TARF. Reverse dates undo later index updates, restoring . At dates 2–25, saved stop-date data reconstruct the stop bit and alive control; post-date accrual words reconstruct the cap decision. Date 26 leaves stop/alive data unchanged. After restoring these controls, the reverse step reloads the same word, subtracts its contributions and combines forward/reverse outcomes in one phase lookup before undoing the index increment. The first-date inverse restores stop/alive data and unlooks up its word before clearing the index. These conditions justify local correction, not an all-input structural certificate for TARF.
Reference and final-circuit stage accounting
Table 7 gives the saved profiles behind Figure 2. Instrumented builds match the retained program identities and secure totals.
| (a) Autocallable | ||
| Stage | Log-return reference | Factor-sum circuit |
| Path: table lookups | 3,600 | — |
| Path: lookup clean-up | 3,600 | — |
| Path: register adds | 6,960 | 894 |
| Asset forms | — | 4,398 |
| Barrier and call tests | 1,000 | 884 |
| Payoff: worst-of forms | — | 460 |
| Payoff: other | 1,650 | 915 |
| Toffoli total | 16,810 | 7,551 |
| (b) TARF | ||
| Stage | Lookup reference | Windowed circuit |
| Index-sum update | 676 | 300 |
| Payment lookup | 4,562 | 3,738 |
| Lookup clean-up | 4,562 | 453 |
| Accumulator adds | 7,384 | 2,072 |
| Knock-out, cap and stop logic | 5,352 | 85 |
| Cap-date correction | 2,058 | 778 |
| Square root | — | 414 |
| Angle table | 3,834 | 541 |
| Toffoli total | 28,428 | 8,381 |
Table 7. Retained Toffoli stage accounting: (a) autocallable and (b) TARF, each comparing its reference and final circuit. Date stages sum both sweeps; each column sums to its secure total. These are implementation comparisons, not controlled ablations.
Proofs and validation methods
Statistical methods and simulator validation
For a circuit fixed before independent validation draws, use the zero-failure bound in § 5.3. The finance studies sample , uniform 22-bit incoming accumulators and evaluator measurement outcomes, unless the all-input theorem removes a dependence. The output event is an angle-tolerance violation; bit-for-bit simulator disagreement and sampled structural failures are separate events.
Table 8 applies that bound at the displayed per-circuit within each declared comparison family, giving simultaneous one-sided 95% coverage. Separate references, studies, development samples and selected inputs are not pooled. Reusing the three fixed second-setting samples does not create new draws.
| Comparison family | Per-circuit | Upper rate |
| Original factor-sum and log-return pair | 0.05/2 | |
| Pair plus fixed-point control; separately, three fixed transfers | 0.05/3 | |
| Fresh second-setting search (four slots) | 0.05/4 | |
| Three fixed plus four fresh slots | 0.05/7 |
Table 8. Declared zero-in- Bonferroni bounds, applied separately to each reference/study. Each family has simultaneous one-sided 95% coverage. Failed or unfilled predeclared search slots remain included. Individual TARF statements instead use for one preselected circuit and event; no joint statement across TARF circuits or all studies is asserted.
The Qualtran kickmix conversion [18] reproduces secure counts and gives zero sampled phase, input and workspace errors in its separate million-input studies. Five deliberately injected faults per circuit (missing phase fixes, a dirty reset, a dirty final qubit, a flipped input and a flipped output) were all detected. Sampled structural success does not close all-input obligations.
Selected autocallable counterexamples
The selected stress population has 900 paths near call, barrier and strike thresholds; the 901-fixture replay adds the distinct historical search failure. Among the 900 deliberately selected paths, the factor-sum circuit has 241 angle-tolerance violations: 79 call-decision cases, 116 knock-in-decision cases, 8 numerical-angle cases and 38 terminal-wrap cases; these diagnostic counts are not loading-law failure probabilities. Table 9 records the other selected-fixture outcomes. Approximate integer coefficients cause decision errors. Signed terminal overflow can create a false worst asset or select the wrong table leaf. The second-setting fitted weights sacrifice rare tail inputs for lower arithmetic cost.
| Circuit / diagnosis | Selected population | Violations |
| Log-return reference; fixed-point control | Same 900 paths, separately | 52 each |
| All second-setting designs | Second-setting 900 boundary paths | 0 each |
| Shift-add / lookup lattice forms | 66 extreme second-setting inputs | 49 / 46 |
| Transferred log-return; other two fixed controls | Same 66 inputs, separately | 26; 0 / 0 |
Table 9. Other selected autocallable fixture outcomes: angle-tolerance violations. The original factor-sum archive separately retains one allowed violation in 100,000 screening paths. No archived circuit was repaired.
Factor-sum proof support
For the frozen factor-sum tape identified in the artifact manifest, the hooked and separately scored tapes must coincide. Cuts isolate each date’s sum update and decision block, terminal materialization , branch logic and eight accumulator adders. Assertions check the live registers at adder boundaries and the complement gates implementing signed addition via . Every live slot initially denotes an independent variable on its declared domain; internal allocations start at zero.
Table 10 gives the output-value obligations. Enumeration exhausts the stated finite domains; cancellation is exact canonical XOR–AND cancellation against a reference adder for all operand values. Each lemma checks that outputs depend only on declared inputs, other live registers are unchanged and internal frees are zero. The terminal market-state and history-flag checks separate by verified support. Structural obligations additionally establish phase cancellation and persistent-state restoration; these do not determine output values. All 92 value lemmas close without SAT; structural phase/restoration checks also use SAT refutations accepted by the independent DRAT checker.
| Statement and domain | Lemmas | Proof method |
| Layout: allocation-only setup; only the eight adder ranges write | 1 | Syntactic |
| Date/factor updates, , : , give | 60 | Enumeration |
| Date decisions: , give and the specified call count. At a call date its counter starts at zero; earlier counters lie in , later counters remain zero | 20 | Enumeration |
| Terminal : ; separately , . Compute signed , , and the five flags | 2 | Enumeration |
| Each accumulator adder: for every operand and incoming accumulator, preserving the operands | 8 | Cancellation |
| Terminal : the eight addends sum to the model value for every , with predicate , and every and (64 flag combinations) | 1 | Enumeration |
Table 10. Factor-sum output-value lemma families (92 lemmas, all proved). Domains are exhaustive; terminal component domains combine through the verified support separation. Execution totals are retained in the certificate inventory.
Write for the breach-counter bound from Appendix § 8.§ 1, and for the terminal no-knock bit. The call flags are .
Initialization supplies zero sums/counters; each date update supplies the decision block’s domain, whose outputs satisfy the next date’s domain. The terminal outputs supply ’s full signed-word and flag domain, so no reachable-image fallback is used. The all-operand adder identities compose with the enumerated addend sum to give
Restoration composes outward from the terminal block: it preserves every live register except for arbitrary cut-point values, and paired forward/reverse dates restore their live registers and clear temporary work. The initially zero workspace therefore returns to zero. Phase cancellation under § 5.1’s measurement semantics supplies the separate coherent-action argument.
The trusted computational base comprises the mirrored gate/measurement semantics, frozen integer model/data, asserted segmentation, canonical symbolic and bitsliced evaluators, Python/NumPy, Tseitin encoding and independent DRAT checker. This is a computational certificate, not a proof-assistant formalization.
Reference-circuit scope. For the log-return and TARF lookup references, inputs are preserved and the unconditioned phase vanishes, but restoration of long-lived state after the reverse sweep remains open. These obligations require reachable-state invariants and wide addition identities; an open obligation is not a demonstrated failure. A TARF per-date decomposition with the accrual-counter invariant closes its counter conditions, but partial closure is not a complete certificate. The artifact manifest identifies the full residual inventory and certificate records.
Implementation checks and numerical records
Independent-reference TARF holdout records
The windowed TARF candidate was fixed before the study. An independent reference was typed from the contract specification and imports neither the task model nor a candidate. The study sampled independent paths from , uniform 22-bit incoming accumulators and evaluator measurement outcomes, recovering unsigned increments modulo . Every path was evaluated at both 60 and 90 decimal digits, with ten guard digits.
| Quantity | Observed result |
| Angle-tolerance violations | |
| Maximum angle error | |
| Sampled structural errors | Zero input modifications, residual phases, dirty frees and nonzero final workspace |
| One-sided 95% upper rate |
Table 11. Independent-reference windowed TARF holdout outcomes.
The Clopper–Pearson bound is for one preselected circuit and primary event, conditional on the numerical reference, without pooling or multiplicity adjustment. Precision agreement is not a certified reference enclosure; sampled structural success is not an all-input proof.
Logical-inverse implementation and replay
The wrappers add two accumulator-complement layers while preserving the forward body and ordinary measurement corrections. Bounded replays checked the negative increment and both composition orders, and , on ordinary and boundary inputs with varied incoming accumulators and independently sampled measurement records. No errors occurred in increments, either composition, input preservation, phase cancellation, clean frees or final workspace. The all-input inverse on clean workspace follows from Corollary 2 and the additive-action proofs; replay only checks implementation. Controlled use, arbitrary initialized workspace and full pricing remain outside these checks.
| Circuit | Added | ||
| Factor-sum | 7,551 | 518 | 44 |
| HHL | 1,057 | 126 | 66 |
Table 12. Retained inverse-wrapper resources; only accumulator-complement gates are added.
Lattice calculation: numerical reliability
The recursion compares the proved integer model with the financial target. Each factor axis is cropped to retain all but of its marginal law; discarded mass is accumulated across dates. At a one-sided call, the angle word is separated from every remaining outcome of the other side by more than units, versus tolerance 10.48576 units, justifying absorption as a violation. The omission allowance does not enclose numerical error.
The vectorized output agrees bit for bit with the integer emulator on all 901 stress/historical fixtures and 20,000 random paths; the emulator agrees with gate-level outputs throughout the million-path study and on all fixtures. The minimum decision margin is approximately , and the smallest gap between an output deviation and the tolerance exceeds angle-word units. These margins support the numerical classifications but are not an outward-rounded certificate. Independent Monte Carlo agrees with the decision-only result; a separate -path study supports the full-output probability and bias.
Probability propagation uses nonnegative terms, about operations per point followed by sums of at most terms. With unit roundoff , the a priori relative-roundoff estimate is far below . Signed bias sums also evaluate transcendental functions. The probability allowance covers omitted mass; the bias allowance covers omitted and call-disagreement mass. Neither certifies all roundoff, transcendental or classification error.
HHL calibration
Task, construction, and resources
The calibration task of Gu et al. [15] preserves a 21-bit input (2,031,616 values) and adds a 33-bit angle word to an arbitrary accumulator . The target is , scaled by , with tolerance rad. The circuit came from the assisted search in Appendix § 11.
Piecewise-quadratic evaluation [13] partitions the domain into 222 aligned leaves of inputs, . A lookup supplies constant, linear and curvature words and shift . The constant is added and measured; controlled swaps normalize the low input window, curvature arithmetic updates the linear word, and seven radix-4 Booth rows [24, 25] add the product. Normalization and curvature updates are reversed, and measurement-based unlookup [10, 12] clears the coefficients. Appendix § 8.4 gives the deferred-phase conditions. The frozen integer model includes row floors, finite windows and carry/borrow corrections; fitting accounts for this arithmetic without certifying transcendental error. The artifact manifest identifies the frozen coefficient data.
Table 13 and Figure 7 compare this angle component. The Häner–Roetteler–Svore (HRS) reconstruction [13] has a product close to the published ; the assisted-search circuit is 14.1% below the best published product, with eleven more qubits. These counts do not establish search reliability or a complete HHL implementation.
Table 13: HHL angle-task resource comparison. Reconstruction and final-circuit counts are retained secure counts; the published point is from Gu et al. [15].
| Circuit | Toffoli gates | Peak qubits | |
| HRS-based reconstruction | 14,922 | 323 | 4,819,806 |
| Best published point | 1,348 | 115 | 155,020 |
| Booth-polynomial circuit | 1,057 | 126 | 133,182 |
Table 13.

Figure 7. HHL angle-calibration resources. The large filled teal circle is the Booth-polynomial circuit, which has exact all-input structural/output proofs and an exhaustive 45-digit-reference accuracy comparison (Section B.5.2); the latter is numerical, without a certified enclosure; hollow teal points have empirical screening evidence only. Squares identify the HRS-based reconstruction and interactive dyadic reference; the orange diamond is the best published circuit of Gu et al. [15]. Dashed curves have equal ; the thin frontier ranks resources, not accuracy. The Booth-polynomial circuit has a lower product than the published circuit and eleven more qubits.
Logical verification and numerical accuracy
The twelve exact logical lemmas in Table 14 establish phase cancellation, clean workspace and the integer increment. Phase coefficients cancel symbolically or vanish on their complete address support; all-operand adder identities and the exhaustive addend sum establish the output. Under § 5.1’s measurement semantics, for every allowed , every accumulator and every measurement record,
| Statement | Checks | Method | Points |
| Exact logical lemmas (12) | |||
| unchanged; unconditioned phase zero; all 902 frees clean; 845 of 899 phase coefficients cancel | 1 | Syntactic | — |
| The other 54 phase coefficients vanish (support ) | 1 | Enumeration | 4,096 |
| Tape equals the secure tape; all 1,163 writes to lie in the eight adder ranges | 1 | Syntactic | — |
| Constant-term adder and seven Booth rows: , frame restored | 8 | Cancellation | — |
| Addends depend only on ; their sum equals the integer model | 1 | Enumeration | 2,031,616 |
| Numerical accuracy check (1; not a logical proof) | |||
| Integer increment versus 45-digit target; no certified reference enclosure | 1 | Numerical | 2,031,616 |
Table 14. HHL verification inventory: twelve exact logical lemmas and a separate numerical accuracy check. Enumeration exhausts the stated domain; cancellation holds for all operands.
The trusted base is the mirrored gate semantics, coefficient data, canonical/bitsliced evaluators, Python/NumPy and asserted segmentation; this is a computational certificate, not a proof-assistant formalization.
The separate exhaustive 45-digit comparison finds a maximum error of approximately 417.45 accumulator units (9.719475 × rad) at , below tolerance 429.4967296 units. No rigorous transcendental-reference error bound or certified interval enclosure is available. A separate Qualtran kickmix conversion [18] reproduces counts and bit-for-bit outputs on random inputs, with zero sampled input, phase or workspace errors. Three proof faults and five simulator fault classes were detected; sampled checks remain distinct from the logical proof.
Corollary 2 supplies the logical inverse on clean workspace, retaining Toffoli count and peak qubits and adding 66 gates. Appendix § 9.§ 4.2 gives the bounded implementation replay. Controlled use and complete HHL integration remain unresolved.
Bias diagnostic and digital disagreement
The lattice bias allowance for omitted and call-disagreement mass is below contract units; it excludes numerical roundoff and is not an enclosure of all numerical error. Sampled intervals use a normal approximation: missing rare wrong outputs can omit their variance and invalidate nominal coverage.
The million-path factor-sum sample contained no rare wrong outputs, while the separate -path study contained 25. Figure 8 shows the resulting interval discrepancy; agreement with the lattice does not certify coverage. Rare-event uncertainty in the log-return reference’s sampled bias also remains unresolved. Exact figure data and full stored values remain in the numerical artifact.
Digital disagreement and angle error. The basis-action disagreement probability in the trace-distance bound of Khattar et al. [18] differs from : even a one-unit digital-word error gives an orthogonal basis word. The effective-payoff inequality in § 5.4 instead uses angle tolerance and exceptional-set probability, with numerical substitution subject to the lattice qualifications.
The manifest identifies a separate gate-level replay of both circuits on the same independent-reference paths, with zero incoming accumulators and fresh measurement seeds; no increment differences or sampled input, phase or workspace errors were observed.
TARF exceptional-event analysis
Selected boundary inputs
A protocol fixed before fixture construction selected 5,218 paths using an independent 60/90-digit reference from the contract constants: all 1,024 first-two-index pairs, reachable knock-out/strike neighbours, window edges, near-cap, deep and tail paths, plus 1,000 loading-law sanity paths. Both circuits used secure build/recounts and the unchanged checker with two measurement histories giving bit-for-bit identical increments; reference and task verdicts agree.
Inside the windows, no tested knock-out or strike decision is wrong. Every selected pre-termination lower crossing gives a wrong output; angle-stage range limits occur only after such crossings. Near-cap failures (Table 15) produce angle errors of 0.010–0.52 rad, sometimes amplified by later negative payments. Diagnosis uses reference flags and counterfactuals, without a gate-level trace. These selected inputs are not additional holdout draws. A separate million-path loading-law sample reaches cap margin without establishing a circuit-failure rate there.
| Circuit | Violations | Window cut | Cap tie | Other | Phase/ancilla/input errors | Largest error (rad) |
| Windowed circuit | 1,038 | 991 | 0 | 0/0/0 | ||
| Lookup reference | 627 | 625 | 2 | 0 | 0/0/0 |
Table 15. Selected-input TARF outcomes. Window cut: below the circuit’s index window before termination. Cap tie: accrual within payment resolution of the cap. Largest error is over paths within the rad tolerance. Counts are diagnostic, not failure rates.
Independent TARF lower-window crossing bound
The windowed circuit’s lower thresholds for dates 1–26 are
Let . With the index probabilities specified below, propagate
Killing crossed mass makes the events counted by disjoint, so is the unrestricted process’s first-passage probability. Ignoring cap and knock-out termination gives a superset of lower crossings while the circuit is alive; this event bound does not cover other failure mechanisms.
Normalize the saved binary64 entries exactly: , . Common-denominator integer weights make convolution, killed mass and mass-conservation checks exact, with powers of the weight sum as denominators. The first-passage probability is , agreeing with a separate float64 convolution. The raw 26-index product measure differs from the normalized crossing mass by at most . Adding this allowance and rounding upward gives
The bound is rigorous for the explicitly normalized stored law, with the stated normalization allowance; it does not certify transcendental generation of the weights or a finite random-number generator. The artifact manifest identifies the exact arithmetic records.
Cap-tie probability analysis
Under a protocol fixed before sampling, this reference-only study draws loading-law paths without running a circuit. At an alive date let be the pre-date accrual plus that date’s payment minus the cap. Define . A path is in if either flipping one such cap decision or persistently shifting the cap threshold just past that margin changes the 60-digit reference angle by more than rad. Let require a later price below 15 before reaching 20.
| Band | Upper endpoint | Relation to selected circuit fixtures |
| Windowed wrong outputs at , none at | ||
| Narrower comparison band for the windowed circuit | ||
| Lookup reference wrong at , correct on all consequential ties with |
Table 16. Reference-defined near-cap events: approximate one-sided 95% Clopper–Pearson upper endpoints from paths, with every near-tie path recomputed at 60 digits. These concern , not circuit failure rates.
At , 2,086 of 35,508 near-tie paths reach ; 1,992 reach , each with maximum flip-or-shift angle change at least rad; the other 94 remain in , with changes up to approximately rad but above tolerance. A second method sums the last index and future after each tie exactly, enumerating or sampling earlier prefixes. It agrees within three combined standard errors for and in every tested band, but does not independently compute . Repeated lattice margins make nonlinear in ; bands are not extrapolated.
A cap-error bound requires the unproved containment that every circuit cap-tie error implies . Boundary inputs suggest this relationship but do not prove it from circuit rounding. The windowed circuit rounds payments to ( from date 14); 26 roundings could accumulate to about . At ( paths), the upper endpoint is approximately , above the task budget. Thus a rounding argument is essential; more boundary tests cannot establish the containment. Conversely, 35 selected consequential paths leave the windowed circuit correct, so membership in does not imply circuit failure.
Under that containment at the table’s windowed and lookup bands, combining the coarse lower-window bound with the cap-event endpoint gives at most for those two windowed-circuit mechanisms. Using the lookup reference’s source-stated cut per date and side, not re-estimated here, gives . These are below the task budget and million-path holdout bounds, but remain conditional mechanism bounds: other failures are not excluded, and no unconditional total circuit-failure bound follows.
Search provenance and reproducibility
The project was underway when Gu et al. [15] appeared; we then adopted its evaluator-guided search organization. Table 17 summarizes the retained runs.
| Study | Budget / trials | Access / assistance | Selection / qualification |
| Autocallable / HHL | 4 / 5 programs; no predeclared stop | Full repository; first program in ideation; HHL handwritten hints | Lowest retained secure product; assisted runs |
| TARF | 7 sessions: ideation, 4 designs, 2 rewrites; 6 programs | Sanitized task/harness; no candidates/history; index-sum model read by 4 sessions; no extra hints | Lowest secure product; preregistered million-path holdout; shared F1 lineage, winner refines F4 |
| Second setting | Ideation + 3 designs (90 min/100 turns); 2 circuits, 1 empty trial | Isolated sessions; task/model/primitives and helper study accessible; no extra hints | Protocol eligibility/seeds/sizes; failed/unfilled slots retained in joint confidence family |
| References / controls | Interactive references; 6 control configurations; 3 fixed transfers | References pre-search; TARF reference excluded; AI-assisted control generator, no model queries in fitting | Valid secure-screening minimum product; ties by qubits then ID; transfers fixed before scoring |
Table 17. Search budgets, access and selection. These runs do not establish repeated-search reliability.
Material deviations. Early searches were assisted; factor-sum reused an earlier put stage. TARF ideation exposed to a prior-design protocol was voided, retained and rerun in isolation. Its programs are refinements, not independent replications; two sessions abandoned their family ideas. Three sessions read their saved output outside the workspace under an audit allowance added during the run. TARF and second-setting searches had no additional run-specific design hints, with task files accessible. Second-setting audits found no repository/prior-result/other-session reads; tool exceptions are recorded. The validation driver was written after search scores were visible, then frozen before protocol-defined final tests. Opus 5.5 is an author-reported model attribution: early exact identifiers and verbatim HHL hints are missing. TARF requested claude-opus-5-5; second-setting ideation/design transcripts report that identifier with high effort.
References
- [1]A. Montanaro. Quantum speedup of Monte Carlo methods. Proc. R. Soc. A, 471: 20150301, 2015. DOI: 10.1098/rspa.2015.0301.DOI
- [2]P. Rebentrost, B. Gupt, and T. R. Bromley. Quantum computational finance: Monte Carlo pricing of financial derivatives. Phys. Rev. A, 98:022321, 2018. DOI: 10.1103/PhysRevA.98.022321.DOI
- [3]Stamatopoulos, N., Egger, D. J., Sun, Y., Zoufal, C., Iten, R., Shen, N., & Woerner, S. (2020). Option pricing using quantum computers. Quantum, 4, 291. https://doi.org/10.22331/q2020-07-06-291
- [4]S. Chakrabarti, R. Krishnakumar, G. Mazzola, N. Stamatopoulos, S. Woerner, and W. J. Zeng. A Threshold for Quantum Advantage in Derivative Pricing. Quantum, 5:463, 2021. DOI: 10.22331/q-2021-06-01-463.DOI
- [5]G. Wang and A. Kan. Option pricing under stochastic volatility on a quantum computer. Quantum, 8:1504, 2024. DOI: 10.22331/q-2024-10-23-1504.DOI
- [6]N. Stamatopoulos and W. J. Zeng. Derivative Pricing using Quantum Signal Processing. Quantum, 8:1322, 2024. DOI: 10.22331/q-2024-04-30-1322.DOI
- [7]F. Cibrario et al. Autocallable Options Pricing with Integration-Based Exponential Amplitude Loading. In 2025 IEEE International Conference on Quantum Computing and Engineering (QCE), volume 1, pages 2459–2469. IEEE, 2025. DOI: 10.1109/QCE65121.2025.00267.DOI
- [8]S. Herbert. Quantum Monte Carlo integration: the full advantage in minimal circuit depth. Quantum, 6:823, 2022. DOI: 10.22331/q-2022-09-29-823.DOI
- [9]S. McArdle, A. Gilyén, and M. Berta. Quantum state preparation without coherent arithmetic. Phys. Rev. Lett., 136:240603, 2026. DOI: 10.1103/ntvs-c48s.DOI
- [10]C. Gidney. Halving the cost of quantum addition. Quantum, 2:74, 2018. DOI: 10.22331/q-2018-06-18-74.DOI
- [11]R. Babbush, C. Gidney, D. W. Berry, N. Wiebe, J. McClean, A. Paler, A. Fowler, and H. Neven. Encoding electronic spectra in quantum circuits with linear T complexity. Phys. Rev. X, 8:041015, 2018. DOI: 10.1103/PhysRevX.8.041015.DOI
- [12]D. W. Berry, C. Gidney, M. Motta, J. R. McClean, and R. Babbush. Qubitization of arbitrary basis quantum chemistry leveraging sparsity and low rank factorization. Quantum, 3:208, 2019. DOI: 10.22331/q-2019-12-02-208.DOI
- [13]T. Häner, M. Roetteler, and K. M. Svore. Optimizing Quantum Circuits for Arithmetic. arXiv:1805.12445, 2018.arXiv
- [14]Zeng, W. J., & Krishnakumar, R. (2022). Using Q# to estimate resources needed for quantum advantage in derivative pricing. Microsoft Azure Quantum Blog.
- [15]A. Gu, A. H. Kemeny, S. F. Yelin, and M. D. Lukin. Discovering state-of-the-art quantum circuits with large language models. arXiv:2610.22367, 2026.arXiv
- [16]Novikov, A., Vu, N., Eisenberger, M., & al., . et . (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery. https://arxiv.org/abs/2506.13131
- [17]Babbush, R., Zalcman, A., Gidney, C., Broughton, M., Khattar, T., Neven, H., Bergamaschi, T., Drake, J., & Boneh, D. (2026). Securing elliptic curve cryptocurrencies against quantum vulnerabilities: Resource estimates and mitigations. PRX Quantum, 7(3), 031001. https://doi.org/10.1103/j3xf-bw18
- [18]T. Khattar, N. C. Rubin, C. Gidney, M. Broughton, G. H. Low, and R. Babbush. Leveraging verifiable structure in quantum circuits to find more efficient compilations with agentic AI. arXiv:2610.23832, 2026.arxiv.org/abs/2610.23832
- [19]Ruiz, F. J. R., Laakkonen, T., Bausch, J., & al., . et . (2025). Quantum circuit optimization with AlphaTensor. Nature Machine Intelligence, 7, 374–385. https://doi.org/10.1038/s42256-025-01001-1
- [20]D. Lizzio Bosco, L. Cincio, G. Serra, and M. Cerezo. Quantum Circuit Pre-Synthesis: Learning Local Edits to Reduce T-count. arXiv:2601.19738, 2026.arxiv.org/abs/2601.19738
- [21]Y. Sim, F. Berto, C. Hua, J. Park, and C. Kwon. LLM-Driven Algorithm Design for Quantum Circuit Synthesis based on Binary Decision Diagrams. arXiv:2609.05327, 2026.arxiv.org/abs/2609.05327
- [22]Jang, K., Kim, H., Seo, H., & Chattopadhyay, A. (2026). Quantum Circuit Optimization with LLMs under a Structured Guideline. IACR Cryptology ePrint Archive. https://eprint.iacr.org/2026/1446eprint.iacr.org/2026/1446
- [23]C. S. Wallace. A suggestion for a fast multiplier. IEEE Trans. Electron. Comput., EC-13:14–17, 1964. DOI: 10.1109/PGEC.1964.263830.DOI
- [24]A. D. Booth. A signed binary multiplication technique. Q. J. Mech. Appl. Math., 4:236–240, 1951. DOI: 10.1093/qjmam/4.2.236.DOI
- [25]O. L. MacSorley. High-speed arithmetic in binary computers. Proc. IRE, 49:67–91, 1961. DOI: 10.1109/JRPROC.1961.287779.DOI