Neural Native Quantum Arithmetic (NNQA)

• NNQA is a quantum arithmetic paradigm that compiles classically trained polynomial models into deterministic circuits using native unitary blocks.
• It employs expectation-value encoding and arithmetic-native primitives to implement exact multiplication and weighted summation for polynomial evaluation.
• The compile-then-execute workflow achieves high accuracy with minimal shot noise error, scaling effectively up to 36 qubits and polynomials of degree 35.

Neural Native Quantum Arithmetic (NNQA) denotes a quantum-arithmetic paradigm in which learned nonlinear structure is compiled into quantum circuits built from arithmetic primitives that act natively on quantum representations rather than through a generic variational ansatz. In its explicit 2026 formulation, NNQA is introduced as a compile-then-execute framework that transforms a classically trained polynomial model into a deterministic quantum arithmetic circuit composed of native unitary blocks, with ideal error attributed only to measurement shot noise once the classical polynomial approximation is fixed (Guo et al., 28 Mar 2026). More broadly, the surrounding literature places NNQA within a larger family of approaches that realize neural or arithmetic computation through expectation values, amplitudes, phases, overlaps, Fourier-domain accumulation, or spectral transformations rather than by direct emulation of classical digital arithmetic inside reversible circuits (Ruiz-Perez et al., 2014, Seidel et al., 2021, Wang et al., 2020, Maronese et al., 2022, Ollive et al., 24 Mar 2025).

1. Definition and conceptual scope

In the formulation introduced in 2026, NNQA targets polynomial synthesis / quantum polynomial arithmetic. The objective is to approximate a continuous scalar function

$\mathcal{F}\in C([-1,1])$

by a polynomial

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$

and then synthesize a quantum circuit $U_P$ such that the measured output observable reproduces the polynomial: $\langle Z_{\mathrm{out}} \rangle = P_d(x).$ The framework is explicitly presented as an alternative to hybrid variational workflows whose runtime is dominated by repeated classical-quantum interaction and whose total error contains optimization error, ansatz approximation error, and shot noise. NNQA instead trains classically, compiles analytically, and executes quantumly, so that the idealized error model becomes

$$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$

rather than

$$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$

The paper characterizes the interface cost of standard variational methods as scaling like $O(pT)$ round trips when a circuit has $p$ trainable parameters and optimization takes $T$ iterations, whereas NNQA uses one quantum execution per evaluated input after classical training (Guo et al., 28 Mar 2026).

Within this framing, “native” refers primarily to arithmetic-native unitary blocks rather than to pulse-level hardware primitives. The central claim is not merely that quantum circuits can approximate nonlinear functions, but that learned polynomial structure can be mapped into a small exact arithmetic basis whose expectation values implement multiplication and weighted summation directly. This distinguishes NNQA from generic parameterized circuits that only represent arithmetic indirectly (Guo et al., 28 Mar 2026).

A broader reading of the literature suggests that NNQA sits at the intersection of several earlier quantum-native arithmetic traditions. Fourier-basis arithmetic recasts addition and weighted accumulation as phase accumulation (Ruiz-Perez et al., 2014). Semi-boolean polynomial methods extend Fourier arithmetic to signed integers, floating-point-like encodings, and polynomial evaluation (Seidel et al., 2021). Quantum amplitude arithmetic proposes direct arithmetic on amplitudes rather than on basis-encoded numbers (Wang et al., 2020). Quantum-neuron and activation-function papers realize overlap-based aggregation, amplitude-domain polynomial evaluation, or phase-similarity computation without conventional multiply-accumulate arrays (Maronese et al., 2022, Mangini et al., 2020, Borba et al., 2024). This suggests that NNQA is best understood not as an isolated construction but as an overview of multiple quantum-native arithmetic motifs.

2. Arithmetic representation and native unitary basis

The explicit NNQA construction is based on Expectation-Value Encoding (EVEN). For an input $x\in[-1,1]$, one prepares

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$0

so that

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$1

Numbers are therefore encoded not as computational-basis integers but as single-qubit expectation values (Guo et al., 28 Mar 2026).

The arithmetic basis is

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$2

For qubits encoding $P_d(x)=\sum_{k=0}^{d} a_k x^k,$3 and $P_d(x)=\sum_{k=0}^{d} a_k x^k,$4, the multiplication primitive is defined as

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$5

with the property

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$6

This primitive is used recursively to generate monomials $P_d(x)=\sum_{k=0}^{d} a_k x^k,$7 (Guo et al., 28 Mar 2026).

The weighted-sum primitive encodes convex aggregation. For qubits encoding $P_d(x)=\sum_{k=0}^{d} a_k x^k,$8 and weight $P_d(x)=\sum_{k=0}^{d} a_k x^k,$9, define

$U_P$0

and let $U_P$1 satisfy

$U_P$2

The explicit circuit form is

$U_P$3

NNQA therefore builds polynomials from two exact expectation-value identities: monomial generation by recursive multiplication and coefficient aggregation by recursive weighted summation (Guo et al., 28 Mar 2026).

Monomials are generated by the recursion

$U_P$4

Polynomial assembly then proceeds backward through partial sums

$U_P$5

with each step implemented by $U_P$6. By construction, the final output qubit satisfies

$U_P$7

Negative coefficients are handled separately: if $U_P$8, the construction uses a sign inversion implemented with an $U_P$9 gate on the corresponding input qubit, and the paper also mentions parity-flip / mid-circuit measurement plus conditional control as a sign-handling mechanism (Guo et al., 28 Mar 2026).

This representation is exact only after normalization. Since expectation values must remain in $\langle Z_{\mathrm{out}} \rangle = P_d(x).$0, the coefficients are rescaled by

$\langle Z_{\mathrm{out}} \rangle = P_d(x).$1

The measured estimator is then un-normalized through

$\langle Z_{\mathrm{out}} \rangle = P_d(x).$2

where $\langle Z_{\mathrm{out}} \rangle = P_d(x).$3 (Guo et al., 28 Mar 2026).

3. Compilation workflow and approximation theory

NNQA is organized into three phases: classical training, deterministic compilation, and quantum execution. The classical model is a polynomial neural network

$\langle Z_{\mathrm{out}} \rangle = P_d(x).$4

trained by minimizing

$\langle Z_{\mathrm{out}} \rangle = P_d(x).$5

After training, the coefficients $\langle Z_{\mathrm{out}} \rangle = P_d(x).$6 are converted analytically into circuit parameters; there is no quantum-side optimization and thus no parameter-shift loop or barren plateau issue during training (Guo et al., 28 Mar 2026).

The coefficient-to-circuit compiler uses a backward recursion. The weights are defined by

$\langle Z_{\mathrm{out}} \rangle = P_d(x).$7

and the corresponding circuit angles are

$\langle Z_{\mathrm{out}} \rangle = P_d(x).$8

The paper emphasizes that this map is closed-form and requires only $\langle Z_{\mathrm{out}} \rangle = P_d(x).$9 classical arithmetic (Guo et al., 28 Mar 2026).

The main theorem is a universal-approximation statement for quantum polynomial arithmetic. For any $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$0 and any $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$1, there exists a polynomial

$$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$2

and a circuit $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$3 built from $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$4 such that

$$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$5

and the measured estimator satisfies

$$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$6

The proof combines Weierstrass approximation, exact monomial construction through $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$7, exact recursive aggregation through $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$8, and Hoeffding-type concentration for the finite-shot estimator (Guo et al., 28 Mar 2026).

The shot-noise analysis is correspondingly standard: $$\epsilon_{\mathrm{classical}}+\epsilon_{\mathrm{shot}}$$9 Thus, in the ideal circuit model, quantum error is reduced to statistical estimation error once the polynomial is fixed. The paper explicitly contrasts this with variational workflows, where total error includes optimization and ansatz components in addition to sampling (Guo et al., 28 Mar 2026).

The reported asymptotic resource counts for degree-$$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$0 polynomial synthesis are linear in degree: $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$1 Compilation cost is $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$2, classical optimization cost is $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$3, and the shot complexity required to reach precision $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$4 is $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$5 (Guo et al., 28 Mar 2026).

4. Antecedents and neighboring paradigms

Earlier work anticipated many NNQA ingredients without presenting the full compile-then-execute polynomial framework. One direct precursor is Fourier-basis arithmetic, where the Quantum Fourier Transform turns addition into phase accumulation. In that setting, the paper on QFT arithmetic provides circuits for addition, signed addition/subtraction, means, weighted sums, multipliers, and a controlled weighted-sum block that computes

$$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$6

using controlled phase rotations, with reported complexities $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$7 for the QFT adder, $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$8 for the multiplier, and $$\epsilon_{\mathrm{opt}}+\epsilon_{\mathrm{ansatz}}+\epsilon_{\mathrm{shot}}.$$9 for a programmable weighted sum (Ruiz-Perez et al., 2014). A later Fourier-arithmetic framework based on semi-boolean polynomial evaluation generalizes this to unsigned arithmetic, signed encodings, in-place operations, arbitrary integer-coefficient polynomial evaluation, and a custom floating-point-like format, reporting for example a 90\% circuit depth reduction for 32-bit unsigned multiplication relative to carry-ripple approaches after transpilation into $O(pT)$0 (Seidel et al., 2021). These works supply a linear-arithmetic substrate but do not provide the expectation-value neural compilation framework of NNQA.

A second precursor is quantum amplitude arithmetic, which explicitly advocates arithmetic on amplitudes rather than on basis-encoded numbers. That work defines addition and multiplication primitives on amplitudes, uses them for black-box state preparation and a tridiagonal Toeplitz quantum linear-system problem, and proposes piecewise polynomial approximation to evaluate nonlinear functions on amplitudes directly (Wang et al., 2020). The amplitude-native polynomial-evaluation idea is especially close to NNQA’s emphasis on native polynomial synthesis, though the representation is probabilistic and branch-selective rather than expectation-value exact.

A third line comes from quantum-neuron and activation-function proposals. The paper on quantum activation functions realizes a perceptron map

$O(pT)$1

for arbitrary analytic activation functions by encoding the normalized pre-activation

$O(pT)$2

as an overlap amplitude, generating monomials $O(pT)$3 in ancilla amplitudes, and constructing a polynomial $O(pT)$4 through a recursive unitary $O(pT)$5 without measurement-induced activation (Maronese et al., 2022). Two related neuron papers encode continuously valued inputs and weights as phases,

$O(pT)$6

and use the overlap probability

$O(pT)$7

as the neuron output, thereby replacing affine weighted sums by phase-difference aggregation and Born-rule nonlinearity (Mangini et al., 2020, Borba et al., 2024). These models are quantum-native in the sense that they avoid register-based adders and multipliers, but they do not implement the same arithmetic object as the NNQA polynomial compiler.

A fourth neighboring paradigm is spectral neural computation. The Widrow-Hoff implementation model does not perform explicit neural arithmetic at all; instead it realizes the asymptotic network map

$O(pT)$8

through phase estimation, amplitude amplification, and Hamiltonian simulation, effectively turning inference into principal-subspace projection (Daskin, 2016). A different redefinition of quantum arithmetic uses embedded QSP to treat arithmetic as operator/query construction rather than reversible bit manipulation, with a pipeline

$O(pT)$9

using transforms such as

$p$0

followed by QPE readout (Ollive et al., 24 Mar 2025). A plausible implication is that NNQA belongs to a wider shift from register-level arithmetic toward operator-level, amplitude-level, and expectation-level arithmetic representations.

5. Experimental validation and hardware behavior

The 2026 NNQA paper validates the framework on IBM Quantum Heron3, IBM Nighthawk, IonQ Forte-1, and Qiskit AerSimulator (Guo et al., 28 Mar 2026). The main task is polynomial recovery. For each degree $p$1, coefficients $p$2 are sampled uniformly from $p$3, polynomials are rescaled so that $p$4 over $p$5, 15 evaluation points are taken uniformly in $p$6, and 10 independent trials per degree yield 900 measurements. For IBM Heron3 the experiments use 4096 shots; the paper quotes a typical standard deviation $p$7, so $p$8 defines the pass-rate threshold. Circuits are transpiled with Qiskit optimization level 3, and no error mitigation—no twirling and no ZNE—is used (Guo et al., 28 Mar 2026).

The reported results show that error is nearly degree-independent over degrees $p$9 through $T$0, and the paper interprets the remaining degradation as primarily hardware noise rather than synthesis error. On AerSimulator, RMSE ranges from $T$1 to $T$2, with correlations between $T$3 and $T$4, and pass rates between $T$5 and $T$6. On IBM Heron3, RMSE ranges from $T$7 to $T$8, correlations from $T$9 to $x\in[-1,1]$0, and pass rates from $x\in[-1,1]$1 to $x\in[-1,1]$2. On IonQ Forte-1, RMSE ranges from $x\in[-1,1]$3 to $x\in[-1,1]$4, correlations from $x\in[-1,1]$5 to $x\in[-1,1]$6, and pass rates from $x\in[-1,1]$7 to $x\in[-1,1]$8 (Guo et al., 28 Mar 2026).

Platform	Degree range	Representative results
AerSimulator	$x\in[-1,1]$9–$P_d(x)=\sum_{k=0}^{d} a_k x^k,$00	RMSE $P_d(x)=\sum_{k=0}^{d} a_k x^k,$01 to $P_d(x)=\sum_{k=0}^{d} a_k x^k,$02
IBM Heron3	$P_d(x)=\sum_{k=0}^{d} a_k x^k,$03–$P_d(x)=\sum_{k=0}^{d} a_k x^k,$04	RMSE $P_d(x)=\sum_{k=0}^{d} a_k x^k,$05 to $P_d(x)=\sum_{k=0}^{d} a_k x^k,$06
IonQ Forte-1	$P_d(x)=\sum_{k=0}^{d} a_k x^k,$07–$P_d(x)=\sum_{k=0}^{d} a_k x^k,$08	RMSE $P_d(x)=\sum_{k=0}^{d} a_k x^k,$09 to $P_d(x)=\sum_{k=0}^{d} a_k x^k,$10
IonQ Forte-1	up to $P_d(x)=\sum_{k=0}^{d} a_k x^k,$11	36 qubits, depth 70, RMSE $P_d(x)=\sum_{k=0}^{d} a_k x^k,$12 at $P_d(x)=\sum_{k=0}^{d} a_k x^k,$13

The IonQ stress test is the strongest empirical scalability result. Sparse degrees $P_d(x)=\sum_{k=0}^{d} a_k x^k,$14 are tested using 5 evaluation points and 1024 shots. The paper reports: $P_d(x)=\sum_{k=0}^{d} a_k x^k,$15, RMSE $P_d(x)=\sum_{k=0}^{d} a_k x^k,$16, correlation $P_d(x)=\sum_{k=0}^{d} a_k x^k,$17, pass $P_d(x)=\sum_{k=0}^{d} a_k x^k,$18, resources $P_d(x)=\sum_{k=0}^{d} a_k x^k,$19 qubits and depth $P_d(x)=\sum_{k=0}^{d} a_k x^k,$20; $P_d(x)=\sum_{k=0}^{d} a_k x^k,$21, RMSE $P_d(x)=\sum_{k=0}^{d} a_k x^k,$22, correlation $P_d(x)=\sum_{k=0}^{d} a_k x^k,$23, pass $P_d(x)=\sum_{k=0}^{d} a_k x^k,$24, resources $P_d(x)=\sum_{k=0}^{d} a_k x^k,$25 qubits and depth $P_d(x)=\sum_{k=0}^{d} a_k x^k,$26. Across degrees $P_d(x)=\sum_{k=0}^{d} a_k x^k,$27–$P_d(x)=\sum_{k=0}^{d} a_k x^k,$28, average RMSE is approximately $P_d(x)=\sum_{k=0}^{d} a_k x^k,$29, and correlation exceeds $P_d(x)=\sum_{k=0}^{d} a_k x^k,$30 for all tested degrees, with average $P_d(x)=\sum_{k=0}^{d} a_k x^k,$31. These data underwrite the abstract’s claims of over 99.5% accuracy for polynomials up to degree 35, execution on 36 qubits, and circuit depths of 70, with a negligible RMSE of $P_d(x)=\sum_{k=0}^{d} a_k x^k,$32 reported in the abstract (Guo et al., 28 Mar 2026).

The IBM architecture comparison emphasizes that NNQA’s arithmetic chain maps favorably onto simple connectivity. On IBM Nighthawk (ibm_miami), the paper reports 10,000 shots, RMSE around $P_d(x)=\sum_{k=0}^{d} a_k x^k,$33, correlations $P_d(x)=\sum_{k=0}^{d} a_k x^k,$34, and 100% pass rate for degrees $P_d(x)=\sum_{k=0}^{d} a_k x^k,$35–$P_d(x)=\sum_{k=0}^{d} a_k x^k,$36. For degrees $P_d(x)=\sum_{k=0}^{d} a_k x^k,$37 to $P_d(x)=\sum_{k=0}^{d} a_k x^k,$38, Heron and Nighthawk exhibit identical transpiled 2-qubit gate counts because the circuits map without SWAPs; for the Heron heavy-hex topology, the paper explicitly reports zero SWAP overhead for tested degrees $P_d(x)=\sum_{k=0}^{d} a_k x^k,$39 (Guo et al., 28 Mar 2026).

6. Limitations, misconceptions, and open directions

NNQA’s exactness is frequently easy to misread. The framework does not claim exact realization of arbitrary continuous functions without approximation; it claims exact realization of the compiled polynomial at the expectation-value level, with overall approximation inherited from the classical polynomial fit and with finite-shot sampling error added at readout (Guo et al., 28 Mar 2026). This distinction matters because the universal-approximation theorem is explicitly a polynomial theorem, not a theorem for unrestricted nonlinear operators.

The scope of the current construction is also narrow in a structural sense. The treatment in the 2026 paper is explicitly one-dimensional scalar polynomial evaluation on $P_d(x)=\sum_{k=0}^{d} a_k x^k,$40. The paper does not fully specify generalized multivariate or matrix/operator extensions, and it requires normalization by $P_d(x)=\sum_{k=0}^{d} a_k x^k,$41 so that output expectations remain in $P_d(x)=\sum_{k=0}^{d} a_k x^k,$42 (Guo et al., 28 Mar 2026). A plausible implication is that extension to vector-valued layers, tensor contractions, or full deep-network arithmetic would require additional compilation rules beyond the univariate recursion given there.

The broader literature highlights further boundary conditions. The analytic-activation paper supplies a coherent activation-function primitive, but it also notes amplitude suppression by $P_d(x)=\sum_{k=0}^{d} a_k x^k,$43, significant ancilla overhead $P_d(x)=\sum_{k=0}^{d} a_k x^k,$44, and expensive arbitrary state preparation, so it does not by itself provide a full scalable weighted-sum substrate (Maronese et al., 2022). Phase-overlap neurons accept continuous-valued inputs without increasing qubit count, but they compute

$P_d(x)=\sum_{k=0}^{d} a_k x^k,$45

rather than a standard affine map $P_d(x)=\sum_{k=0}^{d} a_k x^k,$46, and training remains hybrid and largely classical (Mangini et al., 2020, Borba et al., 2024). QSP-based arithmetic offers a native operator-level route to function evaluation, but it incurs QPE overhead exponential in the number of output bits $P_d(x)=\sum_{k=0}^{d} a_k x^k,$47, parity restrictions, and unquantified approximation error from the $P_d(x)=\sum_{k=0}^{d} a_k x^k,$48 and $P_d(x)=\sum_{k=0}^{d} a_k x^k,$49 stages (Ollive et al., 24 Mar 2025). Fourier-arithmetic approaches remain elegant but rely on many controlled small-angle rotations, and the 2021 semi-boolean polynomial paper explicitly does not analyze fault-tolerant T-count or T-depth for those rotations (Seidel et al., 2021).

These limitations delimit what NNQA currently is. It is not a synonym for all quantum neural computation, nor is it a complete low-level arithmetic stack covering comparison, normalization, division, or general matrix kernels. In the 2026 formulation, it is a deterministic compiler from classically learned polynomial coefficients to expectation-value quantum arithmetic circuits (Guo et al., 28 Mar 2026). In the wider research landscape, it names a family resemblance among approaches that replace register-based digital arithmetic with computation native to phases, amplitudes, overlaps, Fourier representations, or spectral operators (Ruiz-Perez et al., 2014, Wang et al., 2020, Daskin, 2016, Ollive et al., 24 Mar 2025). The literature therefore supports a precise but limited conclusion: NNQA is best regarded as a developing arithmetic paradigm for quantum-native realization of learned polynomial structure, rather than as a complete theory of quantum neural computation.