Arithmetic-Free Quantum Procedures

• Arithmetic-free quantum procedures are approaches that eliminate conventional arithmetic by exploiting quantum-native primitives like superposition and comparison for state preparation and inversion.
• Techniques such as comparison-based amplitude transduction and QET block encoding enable significant reductions in gate counts and ancilla overhead compared to arithmetic-heavy circuits.
• Unoperations generalize quantum inversion processes without forward arithmetic, offering scalable solutions for quantum simulation, analytic state preparation, and factoring.

Arithmetic-free quantum procedures encompass algorithmic strategies and circuit constructions for quantum computation in which conventional arithmetic––such as reversible addition, multiplication, and trigonometric evaluations––is eliminated or circumvented within the quantum device. These techniques leverage physical primitives of quantum hardware, such as superposition, comparison-based operations, and block encoding, to perform state preparation, simulation, or even inversion of classical functions, all without synthesizing large, arithmetic-heavy quantum subroutines. The principal motivation is to reduce the gate and qubit complexity dominated by arithmetic logic, thus widening the viability of quantum algorithms for near-term and fault-tolerant devices.

1. Foundational Principles and Definitions

Arithmetic-free methodology dispenses with circuits that explicitly compute numeric functions or perform arithmetic transformations on quantum data registers. Instead, it exploits quantum-native primitives––notably superposition and comparison––to transduce classical quantities into quantum amplitudes or to invert classical maps:

• In black-box state preparation, amplitude encoding is achieved by comparisons (inequality tests) and uniform superpositions rather than relying on controlled rotations that require the calculation of angles via arithmetic subroutines (Sanders et al., 2018).
• Quantum eigenvalue transformation (QET) uses block-encodings of simple analytic functions (e.g., sine) combined with low-degree polynomial approximations of the target function to sidestep function-value arithmetic in state loading (McArdle et al., 2022).
• Unoperations generalize quantum inverse operations to non-injective classical maps, producing coherent superpositions over all valid preimages, with canonical example being unaddition, where the quantum device generates all (a, b) such that a + b = s (Kohl, 9 Oct 2025).

These approaches systematically avoid the synthesis of reversible arithmetic circuits and large arithmetic-controlled rotation blocks that traditionally underpin quantum algorithmic primitives.

2. Representative Methodologies

2.1 Comparison-Based Amplitude Transduction

The "comp" primitive executes an inequality test at the circuit level (i.e., comp |a⟩|b⟩|0⟩ → |a⟩|b⟩|1⟩ iff a ≥ b), enabling the encoding of numerical values into quantum amplitudes through counting in superposition and selective flagging. Procedure steps involve:

• Loading oracle-amplitude α_ℓ^{(n)} via a black-box amp oracle into the data register.
• Generating a uniform superposition over reference register |x⟩ (Hadamard transform).
• Applying comp to flag register conditioned on data and reference; subsequent unpreparing ref leaves amplitudes proportional to desired values without explicit arithmetic.
• Amplitude amplification restores normalization and success probability (Sanders et al., 2018).

This method structurally avoids arithmetic gates in the amplitude loading stage.

2.2 Quantum Eigenvalue Transformation via Low-Cost Block Encoding

The preparation of |ψ_target⟩ = ∑_x f(x)|x⟩ for analytic or tabulated f(x) is accomplished by:

• Block encoding of the sine operator using a Hadamard control on a single ancilla and a phase-gradient on the data qubits.
• Polynomial (or Fourier) approximation h(y) chosen such that h(sin(2πx/N)) ≈ f(x).
• QET circuit, a special case of QSVT, recursively applies U_sin and its inverse, interleaved with controlled rotations according to the polynomial coefficients.
• Amplitude amplification and measurement yield the target state with resource costs dependent on the filling-fraction of f(x) rather than arithmetic complexity (McArdle et al., 2022).

This provides a parameterized, arithmetic-free template for state preparation with low ancilla overhead.

2.3 Unoperations and Arithmetic Inversion

Unoperation 𝔘n(Ō) for classical functions Ō : X → Y enables quantum inversion:

• The quantum circuit for unaddition prepares superpositions over all (a, b) pairs such that a + b = s, via full-unadder gates and cascaded ripple-carry unadders.
• For multiplication Ō : (x, y) → N = xy, an "unmultiplier" device, constructed by substituting adder circuits with unadders and controlling their activation via enable qubits and feedback modules, yields superpositions over all factor pairs (x, y) for N.
• The architecture scales as O((log N)^2) qubits and gates, entirely obviating forward arithmetic and quantum Fourier transforms (Kohl, 9 Oct 2025).

3. Quantitative Resource Analysis

Arithmetic-free quantum procedures realize significant resource savings:

• In black-box state preparation, Toffoli gate count reduces by factors of 286–374 for typical problem sizes compared to Grover-style circuits, with improved scaling at higher precision. For n = 17–30, transition from O(n^2) to O(n) gates is achieved (Sanders et al., 2018).
• QET state preparation for analytic windows (Gaussian, Kaiser) uses 3–4 ancillas and ~5×10^4 T-gates for n=16, β=10, ε=10^-6, compared to >140 ancillas for reversible arithmetic competitors (McArdle et al., 2022).
• Integer factoring via unmultiplier eschews modular exponentiation and quantum Fourier transforms, scaling qubits and circuit depth as O((log N)^2); whereas Shor's algorithm incurs O(n^3) gates and depth (Kohl, 9 Oct 2025).

A plausible implication is that the elimination of arithmetic bottlenecks opens the tractability of quantum state preparation and discrete inversion for early-stage fault-tolerant quantum devices.

Methodology	Qubit Count	Gate Count
Comp-based amplitude transduction	O(n), + ancillas	O(n√d/∥α⃗∥₂) Toffolis
QET block-encoding	3–4 ancillas	O(nd/F_ṽ,N) T-gates
Unmultiplier	O((log N)^2)	O((log N)^2)

4. Generalizations and Extensions

Arithmetic-free primitives extend to broader classes of quantum operations:

• Any subroutine relying on angle calculation and controlled rotation (e.g., quantum walk step operators, LCU state preparation) may be reformulated using uniform superpositions, comparison-based flagging, and unpreparation stages (Sanders et al., 2018).
• Piecewise-constant or non-monotonic functions can be addressed via multi-comp gates encoding stepwise thresholds. Discontinuous functions require piecewise-QET or gap opening (McArdle et al., 2022).
• Unoperation formalism potentially generalizes to arbitrary classical preimage counting, beyond the examples of addition and multiplication, provided computable preimage sets and manageable ancilla overhead (Kohl, 9 Oct 2025).

This suggests a design principle centered on state counting and comparison, entirely decoupled from forward arithmetic.

5. Practical Applications and Performance Regimes

• Quantum simulation: black-box state preparation without arithmetic is especially impactful in Hamiltonian simulation, where subroutines for coefficient weight encoding employ only comp and Hadamard gates (Sanders et al., 2018).
• Analytic state preparation: QET-based approaches realize order-of-magnitude ancilla savings for windows (Gaussian and Kaiser), relevant in signal processing and error correction (McArdle et al., 2022).
• Factoring and inversion: the unmultiplier device presents arithmetic-free factoring in O((log N)^2) resources, challenging traditional Shor-type implementations for medium-sized integers (Kohl, 9 Oct 2025).

The suitability of these methods is dictated by the number of bits n: comparison-based approaches have overhead scaling linearly with n and are effective up to several hundreds of bits.

6. Limitations, Trade-offs, and Open Directions

Key trade-offs for arithmetic-free procedures involve:

• Increased ancilla and flag register requirements, with circuit depth still scaling as √d or O((log N)^2) depending on problem class.
• Error analyses are governed by truncation (for comparison-based) or polynomial approximation accuracy (for QET), with explicit bounds provided in the respective constructions.
• The design principle of "state counting" by inequality tests holds for monotonic and stepwise functions. For fine-grained continuous or non-monotonic functions, complexity increases and quantum advantage may erode.
• The necessity of amplitude amplification and the need for postselection (in factoring) remain as operational caveats.

Future inquiry is warranted into the systematic extension of unoperations to a wider class of invertible and noninvertible maps, as well as tighter resource estimates for analytic functions beyond those studied (Kohl, 9 Oct 2025). The arithmetic-free paradigm marks an ongoing trend toward hardware-efficient, comparison-based quantum primitives as the field moves into practical fault-tolerant regimes.