---
title: Neural Native Quantum Arithmetic (NNQA)
url: https://www.emergentmind.com/topics/neural-native-quantum-arithmetic-nnqa
type: topic
---

# Neural Native Quantum Arithmetic (NNQA)

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 [2603.27297]. 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 [1411.5949], [2112.10537], [2012.11056], [2201.03700], [2503.18761].

## 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 [2603.27297].

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 [2603.27297].

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 [1411.5949]. Semi-boolean polynomial methods extend Fourier arithmetic to signed integers, floating-point-like encodings, and polynomial evaluation [2112.10537]. Quantum amplitude arithmetic proposes direct arithmetic on amplitudes rather than on basis-encoded numbers [2012.11056]. Quantum-neuron and activation-function papers realize overlap-based aggregation, amplitude-domain polynomial evaluation, or phase-similarity computation without conventional multiply-accumulate arrays [2201.03700], [2007.14288], [2410.23373]. This suggests that NNQA is best understood not as an isolated construction but as a synthesis 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
\[
\theta=\arccos(x), \qquad \ket{\psi(x)} = R_y(\theta)\ket{0},
\]
so that
\[
\langle Z\rangle = x.
\]
Numbers are therefore encoded not as computational-basis integers but as single-qubit expectation values [2603.27297].

The arithmetic basis is
\[
\mathcal{B}=\{U_{\mathrm{mult}},U_{\mathrm{sum}}\}.
\]
For qubits encoding \(x_0\) and \(x_1\), the multiplication primitive is defined as
\[
U_{\mathrm{mult}} = \mathrm{CNOT}_{0,1}\cdot (I \otimes R_z(\pi/2)),
\]
with the property
\[
\langle I \otimes Z \rangle_{U_{\mathrm{mult}}} = \langle Z_0\rangle \cdot \langle Z_1\rangle = x_0x_1.
\]
This primitive is used recursively to generate monomials \(x^k\) [2603.27297].

The weighted-sum primitive encodes convex aggregation. For qubits encoding \(x_0,x_1\) and weight \(w\in[0,1]\), define
\[
\alpha=\arccos(1-2w),
\]
and let \(U_{\mathrm{sum}}(\alpha)\) satisfy
\[
\langle Z\otimes I \rangle_{U_{\mathrm{sum}}} = wx_0+(1-w)x_1.
\]
The explicit circuit form is
\[
U_{\mathrm{sum}}(\alpha)=R_y(-\alpha/2)\cdot \mathrm{CNOT}_{1,0}\cdot R_y(\alpha/2)\cdot U_{\mathrm{mult}}.
\]
NNQA therefore builds polynomials from two exact expectation-value identities: monomial generation by recursive multiplication and coefficient aggregation by recursive weighted summation [2603.27297].

Monomials are generated by the recursion
\[
\ket{\psi_k} = U_{\mathrm{mult}}^{(k-1,k)} \ket{\psi_{k-1}}\otimes \ket{\psi(x)},
\qquad
\langle Z_k\rangle=x^k.
\]
Polynomial assembly then proceeds backward through partial sums
\[
S_d=a_dx^d,\qquad
S_{k-1}=w_{k-1}(a_{k-1}x^{k-1})+(1-w_{k-1})S_k,
\]
with each step implemented by \(U_{\mathrm{sum}}(\alpha_k)\). By construction, the final output qubit satisfies
\[
\langle Z_{\mathrm{out}}\rangle = S_0 = P_d(x).
\]
Negative coefficients are handled separately: if \(\tilde a_k<0\), the construction uses a **sign inversion** implemented with an \(X\) gate on the corresponding input qubit, and the paper also mentions parity-flip / mid-circuit measurement plus conditional control as a sign-handling mechanism [2603.27297].

This representation is exact only after normalization. Since expectation values must remain in \([-1,1]\), the coefficients are rescaled by
\[
\mathcal{C} = \max_{x\in[-1,1]} \left| \sum_{k=0}^d a_k x^k \right| + \epsilon,
\qquad
\tilde a_k=\frac{a_k}{\mathcal C}.
\]
The measured estimator is then un-normalized through
\[
\hat P_d(x)=\mathcal C\cdot \frac{n_0-n_1}{N},
\]
where \(n_0+n_1=N\) [2603.27297].

## 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
\[
\mathcal N_\theta(x)=\sum_{k=0}^{d} a_k(\theta)x^k,
\]
trained by minimizing
\[
\theta^* = \argmin_\theta \frac{1}{M} \sum_{i=1}^M \left( \sum_{k=0}^d a_k(\theta)x_i^k - \mathcal F(x_i) \right)^2.
\]
After training, the coefficients \(a_k:=a_k(\theta^*)\) are converted analytically into circuit parameters; there is no quantum-side optimization and thus no parameter-shift loop or barren plateau issue during training [2603.27297].

The coefficient-to-circuit compiler uses a backward recursion. The weights are defined by
\[
w_k=\frac{|\tilde a_k|}{\sum_{j=k}^{d} |\tilde a_j|},
\]
and the corresponding circuit angles are
\[
\alpha_k=\arccos(1-2w_k)
=
\arccos\left(1-\frac{2|\tilde a_k|}{\sum_{j=k}^{d}|\tilde a_j|}\right).
\]
The paper emphasizes that this map is closed-form and requires only \(O(d)\) classical arithmetic [2603.27297].

The main theorem is a universal-approximation statement for **quantum polynomial arithmetic**. For any \(\mathcal F\in C([-1,1])\) and any \(\epsilon>0\), there exists a polynomial
\[
P_d(x)=\sum_{k=0}^{d} a_k x^k
\]
and a circuit \(U_P\) built from \(\mathcal B=\{U_{\mathrm{mult}},U_{\mathrm{sum}}\}\) such that
\[
\langle Z_{\mathrm{out}}\rangle = P_d(x),
\]
and the measured estimator satisfies
\[
|\mathcal F(x)-\hat P_d(x)|
\le
\underbrace{\|\mathcal F-P_d\|_\infty}_{\epsilon_{\mathrm{classical}}}
+
\underbrace{O(1/\sqrt N)}_{\epsilon_{\mathrm{shot}}}.
\]
The proof combines Weierstrass approximation, exact monomial construction through \(U_{\mathrm{mult}}\), exact recursive aggregation through \(U_{\mathrm{sum}}\), and Hoeffding-type concentration for the finite-shot estimator [2603.27297].

The shot-noise analysis is correspondingly standard:
\[
\Pr\big[|\hat P_d-P_d|>\epsilon\big]\le 2\exp(-2N\epsilon^2).
\]
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 [2603.27297].

The reported asymptotic resource counts for degree-\(d\) polynomial synthesis are linear in degree:
\[
\text{qubits}=d+1,\qquad
\text{circuit depth}=3d+1,\qquad
\text{CNOT gates}=4d-1.
\]
Compilation cost is \(O(d)\), classical optimization cost is \(O(MdE)\), and the shot complexity required to reach precision \(\delta\) is \(N=O(1/\delta^2)\) [2603.27297].

## 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
\[
\sum_{m=1}^N a_m x_m
\]
using controlled phase rotations, with reported complexities \(O(n^2)\) for the QFT adder, \(O(n^3)\) for the multiplier, and \(O(Ntqn)\) for a programmable weighted sum [1411.5949]. 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 \(\{\mathrm{CX},\mathrm{RZ},\mathrm{SX}\}\) [2112.10537]. 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 [2012.11056]. 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
\[
y=f(\vec w\cdot \vec x+b)
\]
for arbitrary analytic activation functions by encoding the normalized pre-activation
\[
z=\frac{\vec w\cdot \vec x+b}{N_{in}+1}\in[-1,1]
\]
as an overlap amplitude, generating monomials \(1,z,z^2,\dots,z^d\) in ancilla amplitudes, and constructing a polynomial \(f_d(z)\) through a recursive unitary \(U_d\) without measurement-induced activation [2201.03700]. Two related neuron papers encode continuously valued inputs and weights as phases,
\[
\ket{\psi_i}=\frac{1}{\sqrt{2^n}}\sum_k e^{i\theta_k}\ket{k},
\qquad
\ket{\psi_w}=\frac{1}{\sqrt{2^n}}\sum_k e^{i\phi_k}\ket{k},
\]
and use the overlap probability
\[
\left|\langle \psi_w|\psi_i\rangle\right|^2
\]
as the neuron output, thereby replacing affine weighted sums by phase-difference aggregation and Born-rule nonlinearity [2007.14288], [2410.23373]. 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
\[
W_{[\infty]}\mathbf x = QQ^T\mathbf x
\]
through phase estimation, amplitude amplification, and Hamiltonian simulation, effectively turning inference into principal-subspace projection [1609.05884]. A different redefinition of quantum arithmetic uses embedded QSP to treat arithmetic as operator/query construction rather than reversible bit manipulation, with a pipeline
\[
\text{binary} \to \text{phase} \to \text{amplitude} \xrightarrow{f} \text{amplitude} \to \text{phase} \to \text{binary},
\]
using transforms such as
\[
\mathrm{p2a}(x)=\frac{2}{\pi}\cos^{-1}(x)-1,
\qquad
\mathrm{a2p}(x)=\sin\left(\frac{\pi}{2}x\right),
\]
followed by QPE readout [2503.18761]. 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** [2603.27297]. The main task is polynomial recovery. For each degree \(d\in\{1,\dots,6\}\), coefficients \(a_k\) are sampled uniformly from \([-0.5,0.5]\), polynomials are rescaled so that \(|P_d(x)|\le 0.5\) over \([-1,1]\), 15 evaluation points are taken uniformly in \(x\in[-0.9,0.9]\), and 10 independent trials per degree yield 900 measurements. For IBM Heron3 the experiments use 4096 shots; the paper quotes a typical standard deviation \(\sigma\approx 0.015\), so \(2\sigma\approx \pm 0.03\) defines the pass-rate threshold. Circuits are transpiled with Qiskit optimization level 3, and **no error mitigation**—no twirling and no ZNE—is used [2603.27297].

The reported results show that error is nearly degree-independent over degrees \(1\) through \(6\), and the paper interprets the remaining degradation as primarily hardware noise rather than synthesis error. On AerSimulator, RMSE ranges from \(0.013\pm0.001\) to \(0.018\pm0.001\), with correlations between \(0.996\) and \(0.999\), and pass rates between \(91.1\%\) and \(97.8\%\). On IBM Heron3, RMSE ranges from \(0.020\pm0.004\) to \(0.024\pm0.004\), correlations from \(0.995\) to \(0.999\), and pass rates from \(74.0\%\) to \(86.0\%\). On IonQ Forte-1, RMSE ranges from \(0.011\pm0.001\) to \(0.019\pm0.001\), correlations from \(0.997\) to \(0.999\), and pass rates from \(92.0\%\) to \(98.2\%\) [2603.27297].

| Platform | Degree range | Representative results |
|---|---:|---|
| AerSimulator | \(1\)–\(6\) | RMSE \(0.013\pm0.001\) to \(0.018\pm0.001\) |
| IBM Heron3 | \(1\)–\(6\) | RMSE \(0.020\pm0.004\) to \(0.024\pm0.004\) |
| IonQ Forte-1 | \(1\)–\(6\) | RMSE \(0.011\pm0.001\) to \(0.019\pm0.001\) |
| IonQ Forte-1 | up to \(35\) | 36 qubits, depth 70, RMSE \(0.008\) at \(d=35\) |

The IonQ stress test is the strongest empirical scalability result. Sparse degrees \(d\in\{1,5,10,15,25,30,35\}\) are tested using 5 evaluation points and 1024 shots. The paper reports: \(d=1\), RMSE \(0.008\), correlation \(0.9999\), pass \(99.0\%\), resources \(2\) qubits and depth \(2\); \(d=35\), RMSE \(0.008\), correlation \(0.9948\), pass \(98.0\%\), resources \(36\) qubits and depth \(70\). Across degrees \(1\)–\(35\), average RMSE is approximately \(0.0155\), and correlation exceeds \(0.994\) for all tested degrees, with average \(0.997\). 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 \(0.005\) reported in the abstract [2603.27297].

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 \(0.01\), correlations \(>99.9\%\), and 100% pass rate for degrees \(1\)–\(6\). For degrees \(3\) to \(6\), 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 \(d=3,\dots,6\) [2603.27297].

## 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 [2603.27297]. 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 \([-1,1]\)**. The paper does not fully specify generalized multivariate or matrix/operator extensions, and it requires normalization by \(\mathcal C\) so that output expectations remain in \([-1,1]\) [2603.27297]. 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 \(2^{-d/2}\), significant ancilla overhead \(d\), and expensive arbitrary state preparation, so it does not by itself provide a full scalable weighted-sum substrate [2201.03700]. Phase-overlap neurons accept continuous-valued inputs without increasing qubit count, but they compute
\[
\left|\langle\psi_w|\psi_i\rangle\right|^2
\]
rather than a standard affine map \(\sum_j w_jx_j+b\), and training remains hybrid and largely classical [2007.14288], [2410.23373]. QSP-based arithmetic offers a native operator-level route to function evaluation, but it incurs QPE overhead exponential in the number of output bits \(F\), parity restrictions, and unquantified approximation error from the \(\mathrm{p2a}\) and \(\mathrm{a2p}\) stages [2503.18761]. 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 [2112.10537].

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 [2603.27297]. 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 [1411.5949], [2012.11056], [1609.05884], [2503.18761]. 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.

Source: https://www.emergentmind.com/topics/neural-native-quantum-arithmetic-nnqa