NNQA: Neural-Native Quantum Arithmetic for End-to-End Polynomial Synthesis

1. Problem Statement

The paper addresses critical bottlenecks in Hybrid Classical-Quantum Learning, specifically within the context of numerical computation and operator evaluation. Current dominant frameworks, such as Variational Quantum Algorithms (VQAs) and Quantum Neural Networks (QNNs), suffer from three main limitations:

• Communication Overhead: Iterative hybrid loops require repeated communication between classical and quantum processors, creating latency and bandwidth bottlenecks.
• Approximation Errors: Generic variational ansatzes represent arithmetic operations indirectly through rotation gates, introducing approximation errors even before hardware noise is considered.
• Trainability Issues: Optimization landscapes in VQAs often suffer from barren plateaus (exponentially vanishing gradients) and non-convex optimization, making convergence difficult and resource-intensive.

Existing methods like Neural Quantum States (NQS) learn wavefunction representations but lack a direct mechanism to convert these into hardware-executable circuits without variational convergence. The authors argue for a paradigm shift from "train-a-circuit" to a "compile-then-execute" approach that eliminates the hybrid optimization loop entirely.

2. Methodology: NNQA

The authors propose Neural-Native Quantum Arithmetic (NNQA), a framework that compiles classically learned nonlinear representations (polynomials) into precise quantum arithmetic circuits composed of native unitary blocks. The process consists of three distinct phases:

Phase 1: Classical Training

• A classical neural network is trained to approximate a target function $F(x)$ using a polynomial representation $P_d(x) = \sum a_k x^k$.
• This training uses standard backpropagation on classical hardware (GPUs), ensuring convex optimization and avoiding barren plateaus.
• The output is a set of learned polynomial coefficients $\{a_k\}$.

Phase 2: Deterministic Compilation

• Instead of optimizing quantum parameters, NNQA uses a closed-form mapping to convert the classical coefficients $\{a_k\}$ directly into quantum rotation angles $\{\alpha_k\}$.
• Normalization: Coefficients are normalized by a constant $C$ to ensure the polynomial value stays within $[-1, 1]$, satisfying quantum encoding constraints.
• Mapping: The normalized coefficients determine the weights for weighted summation and the angles for rotation gates. This step is purely classical and deterministic ($O(d)$ complexity), requiring no quantum queries.

Phase 3: Quantum Execution

• The compiled angles are used to construct a quantum circuit using a specific set of native arithmetic primitives:
  • Angle Encoding: Input $x$ is encoded via $R_y(\arccos(x))$ such that $\langle Z \rangle = x$.
  • Multiplication ($U_{mult}$): Uses CNOT and $R_z$ gates to compute products of expectation values ($\langle Z_0 \rangle \cdot \langle Z_1 \rangle$).
  • Weighted Summation ($U_{sum}$): Uses $R_y$ rotations and CNOTs to compute linear combinations of expectation values.
• The circuit computes the polynomial value directly on the expectation value of the output qubit.
• Error Source: The only deviation from the ideal result is shot noise (statistical sampling error), as the circuit construction itself introduces zero approximation error.

3. Key Contributions

1. Theoretical Framework: The authors prove a Universal Approximation Theorem for NNQA. They demonstrate that any continuous function can be approximated by a polynomial, which can then be exactly represented on a quantum circuit. The total error is decomposed into:
   $$|F(x) - \hat{P}_d(x)| \le \underbrace{\|F - P_d\|_\infty}_{\text{Classical Approximation}} + \underbrace{O(1/\sqrt{N})}_{\text{Shot Noise}}$$
   Crucially, the optimization error ($\epsilon_{opt}$) and ansatz expressibility error ($\epsilon_{ansatz}$) found in VQAs are eliminated.
2. Closed-Form Mapping: A derivation of a deterministic mapping from neural network coefficients to quantum rotation angles, enabling circuit construction without hybrid optimization loops.
3. Error Characterization: Identification that the ideal polynomial evaluation is limited solely by measurement shot noise, independent of the polynomial degree, provided the circuit depth is managed.
4. Hardware Validation: Successful deployment on state-of-the-art NISQ devices (IBM Heron3, IonQ Forte) without variational fine-tuning.

4. Experimental Results

The authors validated NNQA on IBM Quantum Heron3 (superconducting) and IonQ Forte (trapped-ion) processors.

• Accuracy: Achieved >99.5% accuracy for polynomials up to degree 35.
• Scalability: Demonstrated scalability up to 36 qubits and circuit depths of 70 on IonQ hardware.
• Error Metrics:
  • RMSE: Reached a negligible Root Mean Square Error of 0.005 on IonQ.
  • Degree Independence: Unlike VQAs where error increases with circuit depth, NNQA showed consistent RMSE (~0.015) across degrees 1 to 35, confirming that errors are dominated by shot noise rather than circuit synthesis approximation.
• Resource Efficiency:
  • Circuit Depth: $3d + 1$ (linear in degree).
  • Qubits: $d + 1$.
  • Optimization: 0 quantum iterations (1 classical training phase).
  • Comparison: NNQA significantly outperformed VQA baselines in accuracy (0.024 RMSE vs. 0.05–0.10) and pass rates (74% vs. 30–60%) while using far fewer quantum resources.

5. Significance and Impact

• Paradigm Shift: NNQA establishes a new paradigm of "Neural-Native" computation, where neural networks act as compilers for quantum arithmetic rather than just parameterized models.
• Elimination of Hybrid Loops: By removing the classical-quantum optimization loop, NNQA drastically reduces communication latency and avoids barren plateaus, making it highly suitable for current NISQ devices.
• Future Applications: This approach paves the way for direct quantum simulation of nonlinear differential equations, native quantum models, and physical quantum computations where precise arithmetic is required without the overhead of variational training.
• Robustness: The method proves that high-fidelity numerical computation is possible on noisy hardware if the circuit is constructed deterministically based on classical learning, rather than learned stochastically on the hardware.

In summary, NNQA bridges the gap between classical deep learning and quantum computing by leveraging the inductive bias of arithmetic to synthesize exact quantum circuits, offering a scalable, high-accuracy alternative to variational quantum algorithms.