First time studying this topic?

Launch the interactive walkthrough to discover each component, including the 3D Q-Sphere Lab & Python in Colab.

Topic 9.2

Quantum Data Processing & Quantum RAM

Learn how classical datasets are prepared, loaded, and processed inside quantum memories and quantum registers.

Learning Objectives

✓Understand the architecture and concept of Quantum Random Access Memory (QRAM)
✓Analyze the input/output bottleneck in quantum machine learning (the QRAM challenge)
✓Compare quantum state preparation techniques: amplitude encoding, angle encoding, and basis encoding
✓Evaluate quantum data compression via Quantum Principal Component Analysis (qPCA)

📖Let's Begin with a Story

A supercomputer can compute in picoseconds, but if the hard drive transfer speed is slow, the processor sits idle. In quantum computing, we face the ultimate data loading puzzle: how do you convert terabytes of classical pixels or text into delicate quantum superpositions without negating your quantum algorithmic speedup in the preparation phase?

Why Should You Learn Quantum Data Processing & Quantum RAM?

🎯 Practical & Engineering Stakes

Algorithms like HHL and Grover offer quadratic and exponential speedups, but often assume that data already exists in a coherent quantum state. Mastering quantum data encoding and understanding QRAM architecture is essential for building practical end-to-end quantum AI pipelines.

What Is It?

Simple Explanation

Imagine turning a library of millions of books into light beams. QRAM is like a magical indexing system that uses a quantum key to simultaneously highlight every book in the library at once, allowing a quantum algorithm to read the entire catalog in a single flash.

Technical Explanation

Quantum Random Access Memory (QRAM) uses a superposition of addresses

\sum_j a_j |j\rangle

to retrieve memory contents

\sum_j a_j |j\rangle |D_j\rangle

O(\log N)

circuit depth. In practice, coherent state preparation without fault-tolerant QRAM relies on parameterized unitary circuits or amplitude encoding protocols.

📚 Key Terms

QRAM (Quantum RAM)

Simple: Hardware that loads data into quantum states using quantum memory addressing.

Technical: A quantum memory architecture capable of retrieving classical or quantum memory cells using quantum address registers in superposition with

O(\log N)

gate depth.

State Preparation

Simple: The process of translating classical numbers into qubit rotations and superpositions.

Technical: A unitary operation

U_x |0\rangle^{\otimes n} = |\psi_x\rangle

that maps a classical vector

x \in \mathbb{R}^N

into quantum state amplitudes or phases.

Quantum PCA (qPCA)

Simple: A quantum method to find the most important patterns in data with exponential speedup.

Technical: An algorithm that performs spectral decomposition of unknown density matrices

\rho

to extract dominant eigenvectors and eigenvalues in

O(\log d)

time.

Q-Sphere Lab: Quantum Data Processing & Quantum RAM

IBM Q-Sphere Model

Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 9.2

Azimuth: 45°Elevation: 25°(Click & drag sphere to orbit)

Q-Sphere Phase Color:

0 π/2 π 3π/2

Quantum Statevector

dim(H) = 2

|ψ⟩ = (1.000 + 0.000i)|0⟩
+ (0.000 + 0.000i)|1⟩

Polar Angle (θ):0.0° (0.000π rad)

Phase Angle (ϕ):0.0° (0.000π rad)

Born Rule Probabilities: P(x) = |⟨x|ψ⟩|²Σ P = 1.00

P(|0⟩) = |α|²100.0%

P(|1⟩) = |β|²0.0%

Quantum Measurement

Apply Single-Qubit Unitary Gates

Presets:

Continuous Polar Angle θ (0° = |0⟩, 180° = |1⟩):0.0°

Continuous Phase Angle ϕ (0° to 360°):0.0°

Recent Operations Log:

#1Initial state: |0⟩

📐 Mathematical Foundation

LaTeX KaTeX

\sum_{j=0}^{N-1} \alpha_j |j\rangle_A |0\rangle_D \xrightarrow{\text{QRAM}} \sum_{j=0}^{N-1} \alpha_j |j\rangle_A |D_j\rangle_D, \quad T_{\text{lookup}} = \mathcal{O}(\log_2 N)

What does it mean?

Quantum Random Access Memory (QRAM) & Coherent Memory Access: QRAM allows a quantum processor to query an address register A in superposition and retrieve classical data entries D_j into a target data register D without collapsing quantum superposition. Using a binary tree of quantum routers (Bucket Brigade architecture), a lookup across N database records completes in O(log2 N) routing depth, unlocking parallel dataset ingestion for AI.

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$\|j\rangle_A$	Address register state	Superposition over all $N$ data memory addresses
$\|D_j\rangle_D$	Data register state	Classical data record loaded into quantum register at index $j$
$\alpha_j$	Superposition amplitude	Weight or probability amplitude assigned to data record $j$
$T_{\text{lookup}}$	Memory query time complexity	$\mathcal{O}(log_2 N)$ routing depth through binary quantum router tree

📊 Numerical Example

Executing a coherent QRAM superposition lookup across N = 4 memory records (D0=5, D1=12, D2=3, D3=9) using a 2-qubit address register:

Step 1: Prepare Address Register in Equal Superposition: |ψ_addr⟩ = (1/2)[

|00\rangle

|01\rangle

|10\rangle

|11\rangle

] All 4 addresses j ∈ {0, 1, 2, 3} are queried simultaneously. Step 2: Initialize Data Register in Ground State

|0\rangle

: |ψ_initial⟩ = |ψ_addr⟩ ⊗

|0000\rangle

_D = 0.5

|00\rangle

|0\rangle

+ 0.5

|01\rangle

|0\rangle

+ 0.5

|10\rangle

|0\rangle

+ 0.5

|11\rangle

|0\rangle

Step 3: Coherent QRAM Bucket-Brigade Routing (log2(4) = 2 switch layers): Address 00 (j=0) routes to D_0 = 5 (

|0101\rangle

_2) Address 01 (j=1) routes to D_1 = 12 (

|1100\rangle

_2) Address 10 (j=2) routes to D_2 = 3 (

|0011\rangle

_2) Address 11 (j=3) routes to D_3 = 9 (

|1001\rangle

_2) Step 4: Output Superposition State: |ψ_QRAM⟩ = 0.5

|00\rangle

|5\rangle

+ 0.5

|01\rangle

|12\rangle

+ 0.5

|10\rangle

|3\rangle

+ 0.5

|11\rangle

|9\rangle

Result: All 4 records are queried and entangled with their respective addresses in a single logarithmic query step.

⚙️ How Does It Work?

Classical Data Ingestion

Features are normalized to unit Euclidean norm or scaled into phase rotation angles between $[0, \pi]$.

Address Superposition Generation

Hadamard gates create a uniform superposition across all index register qubits.

Coherent Memory Query (Bucket Brigade)

Address qubits route through a binary tree of quantum switches, activating target storage cells simultaneously.

Entangled Data Readout

Data values are entangled with address tags ready for subsequent quantum algorithmic transformations.

🌍 Where Is It Used?

High-Throughput Genome Search

Problem: Scanning billions of DNA base pairs using classical lookup tables requires linear $O(N)$ searches.

Solution: QRAM-indexed genetic sequences allow quantum search algorithms to query genomic patterns in $O(\sqrt{N})$ time.

Real-Time Financial Risk Covariance Updates

Problem: Covariance matrices across tens of thousands of asset prices are computationally prohibitive to invert classically in real time.

Solution: Quantum PCA on streaming financial tick data extracts principal components in logarithmic time.

🎯 Try It Yourself

Why can naive classical-to-quantum state preparation ruin an exponential quantum speedup?

Interactive activity component

🐍 Python Hands-On: Simulating Amplitude Encoding and Unitary State Preparation

Normalize a classical feature vector and prepare its exact quantum state representation using Qiskit or NumPy.

Open Colab

1Install Required Packages

For Google Colab or Jupyter notebooks, run this shell command to install the required dependencies:

Terminal / Notebook Install Commandbash

!pip install qiskit numpy

Packages:

qiskitnumpy

2Import Libraries

Import Statementspython

1 import numpy as np
2 from qiskit import QuantumCircuit
3 from qiskit.quantum_info import Statevector

import numpy as np → Import NumPy for numerical vector normalization

from qiskit import QuantumCircuit → Import Qiskit circuit builder

from qiskit.quantum_info import Statevector → Import statevector simulator

3Demonstration Code & Logic

Python Execution Codepython

1 classical_data = np.array([1.5, -2.0, 3.2, 0.8])
2 norm = np.linalg.norm(classical_data)
3 normalized_amplitudes = classical_data / norm
4 qc = QuantumCircuit(2)
5 qc.initialize(normalized_amplitudes, [0, 1])
6 sv = Statevector.from_instruction(qc)
7 print("Quantum State Vector:")
8 for idx, amp in enumerate(sv.data):
9     print(f"|{idx:02b}> : {amp.real:.4f} + {amp.imag:.4f}j")

Step-by-Step Code Breakdown:

classical_data = np.array([1.5, -2.0, 3.2, 0.8])

4-element classical feature vector

norm = np.linalg.norm(classical_data)

Compute Euclidean L2 norm

normalized_amplitudes = classical_data / norm

Scale vector so sum of squared amplitudes equals 1

qc = QuantumCircuit(2)

Create 2-qubit circuit (2^2 = 4 amplitudes)

qc.initialize(normalized_amplitudes, [0, 1])

Initialize statevector using Qiskit isometry

sv = Statevector.from_instruction(qc)

Simulate the resulting quantum state

print("Quantum State Vector:")

Print label

for idx, amp in enumerate(sv.data):

Iterate amplitudes

print(f"|{idx:02b}> : {amp.real:.4f} + {amp.imag:.4f}j")

Display basis amplitudes

📋 Complete Script (All-in-One)

Click "Copy for Colab", open Google Colab, paste into a single cell, and run.

Google Colab Notebook Scriptpython

1 # =========================================================
2 # Simulating Amplitude Encoding and Unitary State Preparation
3 # Prepared for Google Colab (Run with Shift + Enter)
4 # =========================================================
5  
6 # Step 1: Install required packages
7 !pip install qiskit numpy
8  
9 # Step 2: Import libraries
10 import numpy as np
11 from qiskit import QuantumCircuit
12 from qiskit.quantum_info import Statevector
13  
14 # Step 3: Run Demonstration
15 classical_data = np.array([1.5, -2.0, 3.2, 0.8])
16 norm = np.linalg.norm(classical_data)
17 normalized_amplitudes = classical_data / norm
18 qc = QuantumCircuit(2)
19 qc.initialize(normalized_amplitudes, [0, 1])
20 sv = Statevector.from_instruction(qc)
21 print("Quantum State Vector:")
22 for idx, amp in enumerate(sv.data):
23     print(f"|{idx:02b}> : {amp.real:.4f} + {amp.imag:.4f}j")

⚡ How to Run in Google Colab (3 Quick Steps)

Click "Copy for Google Colab" above.
Click Open New Google Colab Notebook (opens in a new tab).
Click on the first empty code cell, press Ctrl + V (or Cmd + V) to paste, then press Shift + Enter to execute!

Launch Blank Colab Notebook

🔄 Algorithmic Execution Flow

Normalize Features

Ensure Euclidean norm equals 1 to preserve quantum state normalization.

→

Allocate Qubits

Map 4 values onto 2 qubits ($2^2 = 4$).

→

Synthesize Unitary

Decompose the state initialization into a sequence of rotational and CNOT gates.

📥 Input / Initial State

Classical vector: [1.5, -2.0, 3.2, 0.8]

📤 Expected Output

|00>: 0.3644
|01>: -0.4859
|10>: 0.7774
|11>: 0.1944

💡 What Does This Demonstration Show?

The four classical numbers are now encoded directly into the probability amplitudes of the 2-qubit quantum state vector.

Course Learning Resource • Slide DeckLesson 1412 Slides

Lesson 14: Quantum Optimization for Portfolio Selection

Covariance, quadratic programming, SamplingVQE, and portfolio optimization.

Author: Dr. Syed Muzamil Basha• FDP Approved Curriculum

Open in New Tab

📝 Learning Check

Test your understanding with these questions. Remember, this is for learning, not examination!

Question 1: What is the theoretical query time complexity of an efficient bucket-brigade QRAM architecture with N storage cells?

Question 2: In angle encoding, how are continuous classical features typically mapped onto qubits?

Previous: How AI Benefits from Quantum Computing Next: Quantum Optimization in AI

1	import numpy as np
2	from qiskit import QuantumCircuit
3	from qiskit.quantum_info import Statevector

1	# =========================================================
2	# Simulating Amplitude Encoding and Unitary State Preparation
3	# Prepared for Google Colab (Run with Shift + Enter)
4	# =========================================================
5
6	# Step 1: Install required packages
7	!pip install qiskit numpy
8
9	# Step 2: Import libraries
10	import numpy as np
11	from qiskit import QuantumCircuit
12	from qiskit.quantum_info import Statevector
13
14	# Step 3: Run Demonstration
15	classical_data = np.array([1.5, -2.0, 3.2, 0.8])
16	norm = np.linalg.norm(classical_data)
17	normalized_amplitudes = classical_data / norm
18	qc = QuantumCircuit(2)
19	qc.initialize(normalized_amplitudes, [0, 1])
20	sv = Statevector.from_instruction(qc)
21	print("Quantum State Vector:")
22	for idx, amp in enumerate(sv.data):
23	print(f"\|{idx:02b}> : {amp.real:.4f} + {amp.imag:.4f}j")