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:
| Qubits | Values Encoded | Compression |
|---|---|---|
| 2 | 4 | 2x |
| 3 | 8 | 2.7x |
| 4 | 16 | 4x |
| 10 | 1,024 | 102x |
| 20 | 1,048,576 | 52,429x |
This compression enables quantum algorithms to process exponentially large datasets with polynomial qubit resources.
The Circuit
Using Qiskit's initialize (automatic decomposition)
PYTHONqc = QuantumCircuit(2) qc.initialize([a0, a1, a2, a3], [0, 1]) # Qiskit handles decomposition
Manual Decomposition (Mottonen method)
CODEq_0: ---------- CRY(th_00) --- X --- CRY(th_10) --- X --- / | | q_1: RY(th1) -+-------------- -+- ------------------+-+--
- RY(theta1) on qubit 1: Splits amplitude between |0x> and |1x> subspaces
- CRY on qubit 0: Within |0x>, distributes between |00> and |01>
- 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:
| State | Amplitude | Probability |
|---|---|---|
| |00> | 0.1826 | 3.3% |
| |01> | 0.3651 | 13.3% |
| |10> | 0.5477 | 30.0% |
| |11> | 0.7303 | 53.3% |
Running the Circuit
PYTHONfrom 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:
| Method | Depth | Gates | Notes |
|---|---|---|---|
| General (Mottonen) | O(2^n) | O(2^n) | Exact, but expensive |
| Approximate (qRAM) | O(poly(n)) | O(poly(n)) | Requires quantum RAM |
| Special structure | O(poly(n)) | O(poly(n)) | Exploits data patterns |
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
| Encoding | Qubits for N values | Depth | Readout |
|---|---|---|---|
| Amplitude | log2(N) | O(N) | Hard |
| Angle | N | O(1) | Easy |
| Basis | N | O(1) | Easy |
| Dense Angle | N/2 | O(1) | Easy |
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)