Approximate Quantum Adders

• Approximate quantum adders are quantum circuits that produce near-sum states while circumventing the no-cloning and phase ambiguity restrictions of exact quantum addition.
• They leverage constructions like basis adders, QFT truncation, and genetic algorithm optimizations to achieve high average fidelities under noise and resource constraints.
• These adders balance fidelity, circuit depth, and error resilience, enabling scalable implementations in quantum algorithms such as Shor’s factoring and quantum machine learning.

An approximate quantum adder is a quantum unitary or subcircuit designed to produce, given two quantum inputs, an output register whose state closely approximates (up to normalization) the sum of the inputs—in a way forbidden by exact quantum mechanics for arbitrary unknown states. The theory and implementation of approximate quantum adders is driven by both fundamental restrictions, such as the no-go theorem for universal exact addition, and by the need for noise- and resource-efficient arithmetic in quantum information processing.

1. Theory of the Forbidden Quantum Adder

It is impossible to construct a fully general, unitary quantum adder that, given arbitrary unknown inputs $|\psi\rangle, |\phi\rangle$, outputs a register proportional to their sum and possibly some “garbage” ancilla:

$$U : |\psi\rangle|\phi\rangle|0\rangle \mapsto (|\psi\rangle + |\phi\rangle)/N \otimes |\text{garbage}\rangle$$

for all $|\psi\rangle, |\phi\rangle$. The obstruction is a phase ambiguity: a unitary would have to preserve global phase for one input but not for the other, which is impossible. Furthermore, if a perfect adder were realized, it would allow perfect quantum cloning, violating the no-cloning theorem (Alvarez-Rodriguez et al., 2014).

As a consequence, only approximate quantum adders are permitted. These use additional ancilla systems and achieve exact behavior on a restricted set of basis inputs (e.g., computational basis states), extending by linearity to provide an approximate sum for arbitrary superpositions.

2. Explicit Constructions and Fidelity Formulation

2.1 Basis Approximate Adder

A prototypical construction for qubits is the "basis adder," a three-qubit unitary $U_\text{basis}$ that, on the computational basis, realizes:

• $U_\text{basis}|00,0\rangle = |0\rangle|B_1\rangle$
• $U_\text{basis}|01,0\rangle = |+\rangle|B_2\rangle$
• $U_\text{basis}|10,0\rangle = |+\rangle|B_3\rangle$
• $U_\text{basis}|11,0\rangle = |1\rangle|B_4\rangle$ with $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$ and $|B_i\rangle$ orthogonal ancilla states. This mapping extends linearly to all superpositions (Alvarez-Rodriguez et al., 2014, Li et al., 2016).

2.2 Output and Fidelity

After applying the adder to $|{\psi_1}\rangle|{\psi_2}\rangle|0\rangle$, tracing out ancillae, the output on the target register approximates the normalized sum:

$$|\Psi_\text{id}\rangle = \frac{|\psi_1\rangle + |\psi_2\rangle}{\|\,|\psi_1\rangle + |\psi_2\rangle\,\|}$$

The fidelity is quantified as

$$F = \langle \Psi_\text{id}|\,\rho_\text{out}\,|\Psi_\text{id}\rangle$$

where $\rho_\text{out}$ is the reduced density matrix on the sum qubit. Rigorous closed-form expressions exist for all input pairs, with average fidelities for the basis adder in the range $0.93$–$0.96$ for Haar-random qubit pairs, best-case $F=1$, and worst-case $F\approx0.82$ for identical inputs (the restricted cloner limit) (Alvarez-Rodriguez et al., 2014, Li et al., 2016, Lamata et al., 2017).

2.3 Circuit Decomposition

On hardware, the basis adder can be decomposed into CNOTs, controlled-Hadamards, Toffoli gates, and single-qubit rotations. For example, the Rigetti implementation uses 12 CNOT gates, 1 Toffoli gate (itself a composite of 6 CNOTs and 7 single-qubit rotations), 1 controlled-Hadamard, and approximately 18 single-qubit gates (Ding et al., 2018). Gate count reduction (e.g., via genetic algorithms) sharpens the fidelity–resource trade-off.

3. Approximate Adders for Quantum Arithmetic

Approximate quantum adders have been generalized to modular arithmetic, large registers, and quantum Fourier-transform–based addition as required in quantum algorithms.

3.1 Draper and QFT-Based Approximate Adders

Quantum Fourier transform (QFT)–based adders, such as the Draper adder, can be made approximate by omitting small-angle controlled phase gates—"truncated phase adders"—and inserting a minimal number of correction gates. The truncation level $m$ sets a threshold below which rotations $\pi/2^m$ are dropped (White et al., 2021, Agrawal et al., 2023).

• For register size $L$, gate count and $T$-count scale from $O(L^2)$ (full precision) down to $O(mL)$ (truncated), with end-to-end fidelities remaining high if $m$ is chosen to match required error tolerance.
• In Shor's algorithm with $L=2048$, truncating at $m=6$ (i.e., omitting all rotations below $\pi/64$) and adding a small set of corrections yields per-adder fidelity $\gtrsim 0.999998$ and end-to-end algorithm fidelity $\approx 0.95$ even after $O(L^2)$ uses (White et al., 2021).

3.2 Piecewise and Oblivious Runway Adders

For large registers, adders can be structured with "oblivious carry runways" and coset encodings (Gidney, 2019). These are classical reversible circuits on alternative encodings that, when implemented quantumly, guarantee small trace distance from ideal output provided the deviation parameter (fraction of "bad" encodings) is small. Piecewise addition with $r$ runways of length $m$ achieves error $\le (r+1)2^{-m}$ and reduces the asymptotic circuit depth to $O(\log\log n)$.

4. Resource-Error Trade-Offs and Hardware Implementation

Approximate adders are selected to optimize the performance-resource-noise trilemma:

• "Basis adders" are analytic, with minimal depth but limited fidelity for general superpositions.
• Genetic-algorithm–optimized adders can target specific input ensembles, achieving $\sim$95–99% average fidelity with only 8–20 gates for three-qubit circuits (Lamata et al., 2017, Li et al., 2016).
• Truncated QFT adders and piecewise adders permit scalable implementation with controllable error; for fixed output infidelity $\varepsilon$, the required circuit depth scales logarithmically in register size and error tolerance (White et al., 2021, Gidney, 2019).
• In NISQ hardware, depth-optimal "approximate computing" adders (including literal pass-through and single-CNOT XOR circuits) deliver up to 371% improved fidelity under certain noise models, at the cost of increased mean error distance (NMED) and error rate (ER). For example, a zero-depth pass-through adder achieves NMED $\approx$ 0.35 at $n=4$, while a parallel CNOT (XOR-based) adder yields NMED $\approx$ 0.19 (Gaur et al., 2024).

Adder Type	Circuit Depth	Average Fidelity	Noise Resilience
Basis adder	$O(30)$	$\sim$0.95	Moderate
GA-optimized adder	$8$–$20$	$0.92$–$0.97$	Depth-dependent
QFT truncated adder	$O(mL)$	$\geq 0.95$	Highly tunable
Pass-through (AQA1)	$0$	Application-dependent	Maximal for NISQ
Parallel CNOT (AQA2)	$1$	Application-dependent	Good for NISQ

The principal limitations arise from the no-go theorem (fidelity strictly less than unity for general inputs), the depth and gate count constraints imposed by current hardware (NISQ limitations: $T_1/T_2$ times, gate errors, readout errors), and the significant fidelity drop when approximate adders are used outside their optimized input manifold.

5. Noise, Decoherence, and Fidelity Scaling

Approximate adders express a fundamental fidelity–depth–noise trade-off. Circuit depth reduction sharpens noise resilience but may increase the approximation error (e.g., NMED, ER) (Gaur et al., 2024). In Fourier-based adders, truncation error is quantified directly in terms of unperformed phase rotations and can be counteracted up to an extent via sparse correction operations (White et al., 2021). For banded QFT adders with local noise, fidelity $f_m$ satisfies a scaling law:

$$m \geq \frac12\,\log_d\bigg[\frac{(n-1)(d^2-1)\pi^2}{3\delta}\bigg]$$

where increasing $m$ both increases fidelity (by including finer rotations) and enhances decoherence (by increasing circuit depth), yielding a non-monotonic optimum with respect to noise strength (Agrawal et al., 2023). Constant-depth approximate adders can outperform exact implementations in high-noise NISQ scenarios (Gaur et al., 2024, Agrawal et al., 2023).

Coherence loss and output fidelity are linearly related: the normalized $\ell_1$-coherence parameter tracks fidelity decay exactly at each register stage (Agrawal et al., 2023).

6. Applications and Prospects

Approximate quantum adders are employed as primitives for quantum autoencoding (Ding et al., 2018, Lamata et al., 2017), “soft” quantum arithmetic in machine learning and signal processing (Gaur et al., 2024), resource-minimized circuit design for Shor’s factoring and modular exponentiation (White et al., 2021, Gidney, 2019), and as building blocks for error-tolerant arithmetic in NISQ hardware.

Prospective avenues include:

• Machine learning and genetic algorithm co-optimization of adder circuits for target input ensembles and hardware noise models (Lamata et al., 2017).
• Hardware-aware compilation minimizing routing and cross-resonance overhead (Ding et al., 2018).
• Error mitigation in shallow approximate arithmetic, including dynamic correction strategies (White et al., 2021).
• Extension to higher-dimensional qudits and many-body implementations via engineered spin-chain Hamiltonians (Agrawal et al., 2023).

Overall, approximate quantum adders offer a modular, application-contingent trade-off between fidelity, depth, and resource overhead, with tunable error bounds catalyzing their adoption in NISQ-era quantum architectures.