Encoding a 1080p image into a quantum state

How do you represent a classical image — a grid of pixels — as a quantum state that a quantum computer can operate on? This is a deceptively simple question that sits at the center of quantum image processing research. Here is what it actually looks like for a full 1080p image.

The classical picture

A 1080p image is $1920 \times 1080 = 2, 073, 600$ pixels. Each pixel in an 8-bit grayscale image is a value in $[0, 255]$ . In RGB, each pixel is three such values. Classically, this is just a big array. Quantum mechanically, we need to encode both the position of each pixel and its color value into a superposition of basis states.

How many qubits do we need?

Addressing pixels

$1920 \times 1080 = 2, 073, 600$ . The smallest power of 2 that covers this is $2^{21} = 2, 097, 152$ , so we need 21 qubits to address every pixel position — or equivalently, 11 qubits for the row index and 11 for the column.

Encoding color

For 8-bit grayscale: 8 qubits per pixel value. For 24-bit RGB: 8 qubits per channel × 3 channels = 24 qubits total.

The FRQI model

The most studied encoding scheme is FRQI (Flexible Representation of Quantum Images, Le et al., 2011). It encodes a grayscale image as:

∣ I ⟩ = \frac{1}{2 ^{n}} i = 0 \sum 2^{2 n} - 1 (cos θ_{i} ∣0 ⟩ + sin θ_{i} ∣1 ⟩) \otimes ∣ i ⟩

Where $∣ i ⟩$ is the computational basis state representing pixel position $i$ , and $θ_{i} \in [0, π /2]$ encodes the grayscale value mapped from $[0, 255]$ . The color is encoded in the amplitude of a single qubit, and the full state is a superposition over all 2,073,600 pixel positions simultaneously.

For a 1080p image this requires 21 qubits for position and 1 qubit for grayscale intensity — 22 qubits total.

The NEQR model

FRQI encodes color in amplitudes, which are hard to retrieve precisely after measurement. NEQR (Novel Enhanced Quantum Representation, Zhang et al., 2013) encodes the grayscale value in basis states instead:

∣ I ⟩ = \frac{1}{2 ^{n}} i = 0 \sum 2^{2 n} - 1 ∣ f (i)⟩ \otimes ∣ i ⟩

Where $∣ f (i)⟩$ is the 8-qubit binary representation of the pixel's grayscale value. For 1080p this is 21 qubits for position plus 8 qubits for value — 29 qubits total. Exact pixel values are recoverable, not just probabilities.

The MCQI model for full RGB

For full color, MCQI extends NEQR to three 8-qubit color channels:

∣ I ⟩ = \frac{1}{2 ^{n}} i = 0 \sum 2^{2 n} - 1 ∣ R (i)⟩ ∣ G (i)⟩ ∣ B (i)⟩ \otimes ∣ i ⟩

21 qubits for position plus 24 qubits for RGB — 45 qubits total. With 45 logical qubits, the entire color content of a 1080p frame lives in superposition.

The preparation problem

Knowing the circuit architecture is the easy part. Actually preparing this state is hard.

A naive state preparation for $N$ pixels requires $O (N)$ gates — roughly 2 million gates for a 1080p image. This eliminates any quantum advantage for the encoding step itself. Schemes like QPIE (Quantum Probability Image Encoding) and amplitude encoding via Grover-Rudolph reduce the constant factors, but even optimized methods require $O (N)$ depth for arbitrary states.

The quantum advantage does not come from loading the image. It comes from what you do after the image is encoded.

What operations become faster

Once the image is encoded as a quantum state, several standard image processing tasks speed up substantially:

| Operation | Classical | Quantum | |---|---|---| | 2D Fourier transform | $O (N lo g N)$ | $O (lo g^{2} N)$ via QFT | | Edge detection (Sobel) | $O (N)$ | $O (lo g N)$ via quantum convolution | | Pattern search | $O (N)$ | $O (N)$ via Grover | | Histogram computation | $O (N)$ | $O (N)$ via Grover |

For a 1080p image, $O (N) \approx O (1440)$ versus $O (2, 073, 600)$ . That is a real speedup — conditional on having fault-tolerant hardware at the required scale.

Where we are now

Current quantum hardware tops out around 1000–2000 noisy physical qubits. Fault-tolerant logical qubits each require roughly 1000 physical qubits to suppress error rates enough for deep circuits. Full 1080p encoding is firmly in the future.

That said, the theoretical picture is clean. The encoding schemes are well-defined, the qubit counts are modest (45 logical qubits for full RGB), and the algorithmic speedups are proven. The bottleneck is hardware, not theory — and the hardware is improving.

This is what makes quantum image processing an interesting area to watch: the asymptotic advantages are real, the resource requirements are understood, and the gap between where we are and where we need to be is closing.