---
title: Approximate Quantum Adders
url: https://www.emergentmind.com/topics/approximate-quantum-adders
type: topic
---

# Approximate Quantum Adders

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

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 [1411.4534, 1611.07851].

### 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) [1411.4534, 1611.07851, 1709.07409].

### 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 [1807.10643]. 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 [2110.00217, 2310.11514].

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

### 3.2 Piecewise and Oblivious Runway Adders

For large registers, adders can be structured with "oblivious carry runways" and coset encodings [1905.08488]. 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 [1709.07409, 1611.07851].
- 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 [2110.00217, 1905.08488].
- 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 [2408.00927].

| 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) [2408.00927]. 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 [2110.00217]. 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 [2310.11514]. Constant-depth approximate adders can outperform exact implementations in high-noise NISQ scenarios [2408.00927, 2310.11514].

Coherence loss and output fidelity are linearly related: the normalized $\ell_1$-coherence parameter tracks fidelity decay exactly at each register stage [2310.11514].

## 6. Applications and Prospects

Approximate quantum adders are employed as primitives for quantum autoencoding [1807.10643, 1709.07409], “soft” quantum arithmetic in machine learning and signal processing [2408.00927], resource-minimized circuit design for Shor’s factoring and modular exponentiation [2110.00217, 1905.08488], 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 [1709.07409].
- Hardware-aware compilation minimizing routing and cross-resonance overhead [1807.10643].
- Error mitigation in shallow approximate arithmetic, including dynamic correction strategies [2110.00217].
- Extension to higher-dimensional qudits and many-body implementations via engineered spin-chain Hamiltonians [2310.11514].

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.

Source: https://www.emergentmind.com/topics/approximate-quantum-adders