Logarithmic Qubit Encoding for Resource Efficient Quantum Computing

96 concepts70 papers2 proposals

In early quantum computing paradigms, mapping a physical system or a classical optimization problem to quantum hardware followed a straightforward, direct approach: assign one qubit to each variable, spin, or molecular orbital. While conceptually simple, this one-to-one mapping creates a severe resource bottleneck. As problem sizes grow, the physical qubit requirements quickly outstrip the capacity of near-term—and even early fault-tolerant—quantum devices.

To bypass this limitation, a rapidly growing body of research focuses on logarithmic qubit encoding and resource-efficient mapping. Instead of treating qubits as individual binary switches, these strategies exploit the exponential dimensionality of the quantum state space, non-commuting measurement bases, and physical problem symmetries to compress the required qubit count from linear or quadratic scaling down to logarithmic scaling.

Mapping Variables to State Space Amplitudes

The core mathematical intuition behind logarithmic encoding lies in the structure of the quantum state itself. A register of $n$ qubits defines a Hilbert space of dimension $2^n$, meaning a pure quantum state is described by $2^n$ complex amplitudes:

$$\lvert\psi\rangle = \sum_{i=1}^{2^n} c_i \lvert i\rangle$$

Instead of mapping $N$ classical variables to $N$ distinct qubits, amplitude encoding maps those $N$ variables directly to the coefficients $c_i$ or the discrete states $\lvert i\rangle$ within this exponentially large space. This shift alters the hardware requirements from $O(N)$ qubits to just $O(\log N)$ qubits.

This strategy has proven highly effective across diverse optimization domains. For instance, Hongyi Zhou et al. demonstrated that encoding optimization variables into the amplitudes of a quantum state allows high-dimensional quadratically constrained quadratic programs (QCQPs) to be processed with logarithmic qubit scaling relative to the number of variables (A hybrid algorithm for quadratically constrained quadratic optimization problems).

In the context of semidefinite programming for NP-hard problems like MaxCut, Jean Kossaifi et al. introduced a variational framework that leverages this spatial compression, enabling the representation of tens of thousands of variables using fewer than twenty physical qubits (Quantum Goemans-Williamson Algorithm with the Hadamard Test and Approximate Amplitude Constraints). Similarly, in graph data processing, Meng Shi et al. utilized logarithmic qubit scaling to encode extensive numerical datasets, such as edge weights, bypassing the traditional linear or quadratic resource growth (A Quantum Framework for Combinatorial Optimization Problem over Graphs).

First Quantization and Coordinate Tracking

The power of logarithmic scaling is equally pronounced in quantum simulation, notably through the paradigm shift from second quantization to first quantization.

In second quantization (the standard method for near-term quantum chemistry), qubits represent orbital occupancies. If a simulation requires a large basis set of $N$ orbitals to achieve high precision, it demands $N$ qubits. First quantization, however, tracks the coordinates of the $\eta$ particles themselves. Each particle's position is stored as a binary address in a quantum register.

As Ryan Babbush et al. demonstrated, tracking particle coordinates rather than orbital occupancy yields a space complexity that scales logarithmically with the number of basis functions, requiring roughly $O(\eta \log N)$ qubits (Quantum simulation of exact electron dynamics can be more efficient than classical mean-field methods). When the basis set size significantly exceeds the number of particles—such as in high-precision simulations—this first-quantized approach offers an exponential reduction in memory compared to classical storage.

Second Quantization (Linear Scaling):
Orbital 1    Orbital 2    Orbital 3    Orbital 4
  [|1⟩]        [|0⟩]        [|1⟩]        [|0⟩]      --> Requires N qubits for N orbitals

First Quantization (Logarithmic Scaling):
Particle 1 Register      Particle 2 Register
  [|0⟩|0⟩] (Index 0)       [|1⟩|0⟩] (Index 2)       --> Requires η log(N) qubits

This logarithmic scaling is vital when simulating highly oscillatory systems, such as the time-dependent Schrödinger equation in the semi-classical regime studied by Shi Jin et al. (Quantum simulation in the semi-classical regime). In this regime, the number of qubits required to maintain high spatial resolution scales logarithmically with the inverse of the scaling parameter, protecting the simulation from prohibitive memory overhead.

Furthermore, the historical bottleneck of initializing these complex states has been mitigated by the authors of Efficient state preparation for the quantum simulation of molecules in first quantization, who developed a tensor-network-based state preparation scheme that brings the gate complexity down to a polylogarithmic function of the number of plane waves.

Dense Packing via Multi-Basis Encodings

Another facet of resource-efficient mapping involves packing multiple classical variables into a single physical qubit by exploiting non-commuting measurement bases ($X, Y,$ and $Z$). Because these bases represent independent degrees of freedom on the Bloch sphere, a single qubit can simultaneously store compressed information about multiple problem variables.

Taylor L. Patti et al. leveraged this property by introducing Multi-Basis Encoding (MBE), a technique that maps graph vertices into both the $Z$ and $X$ bases of a qubit register (Variational quantum optimization with multibasis encodings). By using nonlinear activation functions to decode these overlapping states, MBE reduces the physical qubit requirement for combinatorial optimization problems by half.

Extending this concept to its geometric limit, Yan Jin et al. incorporated quantum random access codes (QRACs) to map three classical binary variables onto the $X, Y,$ and $Z$ bases of a single qubit (Quantum Relaxation for Solving Multiple Knapsack Problems). This achieves a strict 3:1 compression ratio:

$$\text{Qubit State} \implies \langle X \rangle \sim b_1, \quad \langle Y \rangle \sim b_2, \quad \langle Z \rangle \sim b_3$$

This dense representational strategy allows near-term, resource-constrained quantum hardware to process large optimization instances, such as the Multiple Knapsack Problem, that would otherwise exceed available physical qubit counts.

Exploiting Subspace Symmetries and Truncations

Logarithmic and sublinear efficiencies can also be unlocked by identifying physical constraints or symmetries that render large portions of the standard Hilbert space redundant, allowing researchers to map only the active physical states.

In quantum chemistry, the "seniority-zero" approximation assumes that electrons remain paired within spatial orbitals. By restricting the simulation to this specific subspace, José A. Gámez et al. demonstrated that the standard spin-orbital mapping can be compressed to exactly one qubit per spatial orbital, halving the hardware resources needed to model stable molecules (Simulating quantum chemistry in the seniority-zero space on qubit-based quantum computers).

The single-author work of Yu Shee combined these state-space constraints with a qubit-efficient encoding (QEE) scheme, achieving a logarithmic reduction in qubit requirements when predicting molecular tautomers by mapping only the strictly necessary physical configurations (Quantum simulation of preferred tautomeric state prediction).

A similar principle applies to continuous or high-dimensional systems that must be truncated for digital quantum hardware, such as lattice gauge theories. Guglielmo Mazzola et al. showed that mapping truncated spin states to qubits using a binary representation yields a highly efficient logarithmic encoding (Toward scalable simulations of lattice gauge theories on quantum computers). When the number of truncated states is chosen to be a power of two, the number of required Pauli strings scales linearly with the truncation level rather than quadratically, minimizing both the spatial memory and the measurement overhead required for the simulation.

Key Foundational Work

Simulated Quantum Computation of Molecular Energies (2005) — contributed 2 concept elements to this direction.
Polynomial-time quantum algorithm for the simulation of chemical dynamics (2008) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_logarithmic_qubit_scaling_8ff4d357,
  title = {logarithmic qubit scaling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/logarithmic-qubit-scaling/rdr_8ff4d357e3e743148c0bedcf6598723f},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_logarithmic_qubit_scaling_8ff4d357_v1,
  title = {logarithmic qubit scaling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/logarithmic-qubit-scaling/rdr_8ff4d357e3e743148c0bedcf6598723f/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake