Amplitude Encoding

Overview

Amplitude encoding is the most compact quantum data encoding: it stores N classical values in just log2(N) qubits by encoding them as probability amplitudes of a quantum state. This exponential compression is one of the key advantages quantum computing offers for data-intensive tasks.

The encoding maps a normalized vector [a0, a1, a2, a3] to the quantum state:

|psi> = a0|00> + a1|01> + a2|10> + a3|11>

The amplitudes must satisfy the normalization constraint: sum(|ai|^2) = 1.

Exponential Compression

The defining feature of amplitude encoding is logarithmic qubit scaling:

This compression enables quantum algorithms to process exponentially large datasets with polynomial qubit resources.

The Circuit

Using Qiskit's initialize (automatic decomposition)

PYTHONCopy
qc = QuantumCircuit(2)
qc.initialize([a0, a1, a2, a3], [0, 1])  # Qiskit handles decomposition

Manual Decomposition (Mottonen method)

CODECopy
q_0: ---------- CRY(th_00) --- X --- CRY(th_10) --- X ---
               /               |                     |
q_1: RY(th1) -+-------------- -+- ------------------+-+--

1. RY(theta1) on qubit 1: Splits amplitude between |0x> and |1x> subspaces
2. CRY on qubit 0: Within |0x>, distributes between |00> and |01>
3. X + CRY + X: Within |1x>, distributes between |10> and |11>

Encoding Example

Data: [1, 2, 3, 4]

Normalized: [0.1826, 0.3651, 0.5477, 0.7303]

Measurement probabilities:

Running the Circuit

PYTHONCopy
from circuit import (
    run_circuit,
    create_amplitude_encoding,
    create_amplitude_encoding_manual,
    normalize_data,
    verify_encoding,
)

# Encode and measure
result = run_circuit(data=[1.0, 2.0, 3.0, 4.0])
print(f"Normalized: {result['normalized_amplitudes']}")
print(f"Measured: {result['measured_probs']}")

# Manual decomposition (explicit gates)
qc = create_amplitude_encoding_manual([1.0, 2.0, 3.0, 4.0])

# Verify encoding correctness
v = verify_encoding(data=[1.0, 2.0, 3.0, 4.0])
print(f"All checks passed: {v['passed']}")

State Preparation Cost

The tradeoff for exponential compression is state preparation complexity:

For small datasets (2-4 qubits), exact preparation is practical. For larger datasets, approximate methods or structured data are needed.

Advantages

• Exponential compression: N values in log2(N) qubits
• Natural for QML: Feature vectors map directly to quantum states
• Quantum parallelism: Process all values simultaneously
• Inner product access: Overlap between encoded states gives similarity

Challenges

• State preparation cost: General preparation is O(2^n) gates
• Readout bottleneck: Extracting all amplitudes requires O(2^n) shots
• Normalization requirement: Data must be L2-normalized
• No classical readout shortcut: Cannot efficiently extract arbitrary amplitudes

Comparison with Other Encodings

Applications

• Quantum machine learning: Feature vector encoding for QML algorithms
• Quantum simulation: Initial state preparation for Hamiltonian simulation
• Quantum search: Oracle input preparation for Grover's algorithm
• Quantum linear algebra: Loading data for HHL and related algorithms

Learn More

• Supervised Learning with Quantum Computers (Schuld & Petruccione, 2018)
• Transformation of Quantum States Using Uniformly Controlled Rotations (Mottonen et al., 2005)
• Data Encoding for Quantum Machine Learning (Weigold et al., 2020)