First time studying this topic?

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

Topic 6.2

Quantum Registers & Multi-Qubit State Vectors

Understand how multiple qubits assemble into quantum registers, and master little-endian vs big-endian bit ordering.

Learning Objectives

✓Define Quantum Registers as collections of qubits indexed in composite Hilbert spaces
✓Master endianness: IBM Qiskit (Little-Endian) vs Textbooks (Big-Endian)
✓Calculate the dimensionality and basis vectors for n-qubit registers

📖Let's Begin with a Story

In 1726, Jonathan Swift published Gulliver’s Travels, where two rival empires went to war over which end of a hard-boiled egg should be cracked open: the big end or the little end. In 1980, computer scientist Danny Cohen adopted this satire to describe computer memory: Endianness. In quantum computing, endianness causes more bugs for beginners than almost anything else! - In Textbooks (Big-Endian): The top qubit

q_0

is the leftmost bit:

|q_0 q_1\rangle

. - In IBM Qiskit (Little-Endian): The top qubit

q_0

is the rightmost bit:

|q_1 q_0\rangle

! If you measure

q_0 = 1

and

q_1 = 0

, a textbook calls it "10", while Qiskit calls it "01"! Understanding how registers order qubits is critical to avoid reading your quantum results backwards.

Why Should You Learn Quantum Registers & Multi-Qubit State Vectors?

🎯 Practical & Engineering Stakes

Register hygiene

A single bug in register endianness inverts your entire algorithm's output. Mastering multi-qubit register representation guarantees your code matches textbook mathematics.

What Is It?

Simple Explanation

A Quantum Register is like a row of lightbulbs: - 1 qubit: holds 2 states (|0>, |1>). - 2 qubits: holds 4 states (|00>, |01>, |10>, |11>). - 3 qubits: holds 8 states (|000> through |111>). - 10 qubits: holds 1,024 states simultaneously! Every time you add a single qubit to the register, its memory capacity doubles!

Technical Explanation

n

-qubit register represents a state vector

|\psi\rangle = \sum_{j=0}^{2^n-1} c_j |j\rangle

in Hilbert space

\mathcal{H}^{\otimes n} \cong \mathbb{C}^{2^n}

. Basis states

|j\rangle

correspond to the binary expansion

j = \sum_{k=0}^{n-1} b_k 2^k

. In big-endian ordering,

|j\rangle = |b_{n-1} b_{n-2} \dots b_0\rangle

; in little-endian (Qiskit),

|j\rangle = |b_0 b_1 \dots b_{n-1}\rangle

📚 Key Terms

Quantum Register

Simple: A group of qubits treated as a single memory unit.

Technical: An ordered collection of

n

qubits whose combined state space is formed via tensor products

\bigotimes_{i=0}^{n-1} \mathcal{H}_i

Little-Endian (Qiskit)

Simple: Qubit 0 is on the far right (like standard binary numbers: 1s place on right).

Technical: Ordering where the least significant bit corresponds to qubit index 0:

|q_{n-1} \dots q_1 q_0\rangle

Big-Endian (Textbooks)

Simple: Qubit 0 is on the far left.

Technical: Ordering where the most significant bit corresponds to qubit index 0:

|q_0 q_1 \dots q_{n-1}\rangle

Q-Sphere Lab: Quantum Registers & Multi-Qubit State Vectors

IBM Q-Sphere Model

Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 6.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

|\psi\rangle = \sum_{x=0}^{2^n-1} c_x |x\rangle = c_0 |00\dots0\rangle + c_1 |00\dots1\rangle + \dots + c_{2^n-1} |11\dots1\rangle

What does it mean?

Multi-Qubit Quantum Register Representation: An n-qubit quantum register does not store just n classical bits. It holds a simultaneous superposition of all 2^n binary configurations at once, each weighted by a complex probability amplitude c_x whose squared magnitudes sum to 100%.

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$n$	Register width (qubit count)	The number of quantum wires grouped together
$2^n$	Total basis states	Exponential dimension: 2 qubits = 4 states, 3 qubits = 8 states, $n$ qubits = $2^n$ states
$\|x\rangle$	Binary basis state bitstring	Standard integer encoded as binary (e.g., $\|0\rangle=\|00\rangle$ , $\|1\rangle=\|01\rangle$ , $\|2\rangle=\|10\rangle$ , $\|3\rangle=\|11\rangle$ )
$c_x$	State probability amplitude	Complex number whose squared magnitude gives real probability $P(x) = \|c_x\|^2$

📊 Numerical Example

Evaluating a 2-qubit register (n = 2, 2^2 = 4 states) in state |ψ⟩ = 0.5|00⟩ + 0.5|01⟩ + 0.5|10⟩ + 0.5|11⟩:

State vector as a 4-element column:

|\psi\rangle

= [c_0, c_1, c_2, c_3]^T = [0.5, 0.5, 0.5, 0.5]^T Calculate measurement probabilities: • P(

|00\rangle

= 0) = |0.5|^2 = 0.25 (25%) • P(

|01\rangle

= 1) = |0.5|^2 = 0.25 (25%) • P(

|10\rangle

= 2) = |0.5|^2 = 0.25 (25%) • P(

|11\rangle

= 3) = |0.5|^2 = 0.25 (25%) Total: 0.25 + 0.25 + 0.25 + 0.25 = 1.00 (100% normalized) ✓

Result: A 2-qubit register holds all 4 numbers (0, 1, 2, 3) simultaneously with equal 25% probability.

⚙️ How Does It Work?

Allocation

Allocate n quantum wires and n classical measurement bits.

Parallel Initialization

Apply Hadamard gate H across all n wires to create a uniform superposition of 2^n integers.

Targeted Gate Addressing

Apply multi-qubit gates referencing specific qubit indices (e.g. CNOT(control=0, target=1)).

🌍 Where Is It Used?

Quantum Arithmetic (Adders & Multipliers)

Problem: Adding two numbers in a quantum circuit without classical ALU hardware.

Solution: Quantum Draper adder encodes numbers in register phases using Quantum Fourier Transforms.

🎯 Try It Yourself

In IBM Qiskit (Little-Endian), qubit 0 is measured as "1" and qubit 1 is measured as "0". How does Qiskit format the output bitstring?

Interactive activity component

🐍 Python Hands-On: Managing Quantum and Classical Registers in Qiskit

Construct modular quantum circuits using named QuantumRegister and ClassicalRegister blocks in Qiskit.

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

Packages:

qiskit

2Import Libraries

Import Statementspython

1 from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit → Register and circuit classes

3Demonstration Code & Logic

Python Execution Codepython

1 # 1. Define named modular registers
2 data_reg = QuantumRegister(2, name='data')        # 2 data qubits
3 ancilla_reg = QuantumRegister(1, name='ancilla')  # 1 ancilla qubit
4 meas_reg = ClassicalRegister(3, name='readout')   # 3 classical bits
5  
6 # 2. Assemble circuit from registers
7 qc = QuantumCircuit(data_reg, ancilla_reg, meas_reg)
8 qc.h(data_reg[0])                 # Gate on data qubit 0
9 qc.cx(data_reg[0], data_reg[1])   # Gate across data qubits
10 qc.cx(data_reg[1], ancilla_reg[0]) # Gate into ancilla
11 qc.measure(data_reg, meas_reg[0:2])
12 qc.measure(ancilla_reg[0], meas_reg[2])
13 print('Circuit with Named Registers:')
14 print(qc.draw('text'))

Step-by-Step Code Breakdown:

# 1. Define named modular registers

Registers

data_reg = QuantumRegister(2, name='data') # 2 data qubits

Data qubits

ancilla_reg = QuantumRegister(1, name='ancilla') # 1 ancilla qubit

Ancilla qubit

meas_reg = ClassicalRegister(3, name='readout') # 3 classical bits

Classical bits

# 2. Assemble circuit from registers

Assemble

qc = QuantumCircuit(data_reg, ancilla_reg, meas_reg)

Combine registers

qc.h(data_reg[0]) # Gate on data qubit 0

H on data[0]

qc.cx(data_reg[0], data_reg[1]) # Gate across data qubits

CNOT across data

qc.cx(data_reg[1], ancilla_reg[0]) # Gate into ancilla

CNOT into ancilla

qc.measure(data_reg, meas_reg[0:2])

Measure data

qc.measure(ancilla_reg[0], meas_reg[2])

Measure ancilla

print('Circuit with Named Registers:')

Label

print(qc.draw('text'))

Print diagram

📋 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 # Managing Quantum and Classical Registers in Qiskit
3 # Prepared for Google Colab (Run with Shift + Enter)
4 # =========================================================
5  
6 # Step 1: Install required packages
7 !pip install qiskit
8  
9 # Step 2: Import libraries
10 from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
11  
12 # Step 3: Run Demonstration
13 # 1. Define named modular registers
14 data_reg = QuantumRegister(2, name='data')        # 2 data qubits
15 ancilla_reg = QuantumRegister(1, name='ancilla')  # 1 ancilla qubit
16 meas_reg = ClassicalRegister(3, name='readout')   # 3 classical bits
17  
18 # 2. Assemble circuit from registers
19 qc = QuantumCircuit(data_reg, ancilla_reg, meas_reg)
20 qc.h(data_reg[0])                 # Gate on data qubit 0
21 qc.cx(data_reg[0], data_reg[1])   # Gate across data qubits
22 qc.cx(data_reg[1], ancilla_reg[0]) # Gate into ancilla
23 qc.measure(data_reg, meas_reg[0:2])
24 qc.measure(ancilla_reg[0], meas_reg[2])
25 print('Circuit with Named Registers:')
26 print(qc.draw('text'))

⚡ 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

Declare Registers

Create distinct QuantumRegister objects for data and ancilla qubits.

→

Compose Circuit

Build multi-register circuit with structured addressing.

→

Route & Measure

Map quantum register wires directly into corresponding classical readout indices.

📥 Input / Initial State

QuantumRegisters ('data' and 'ancilla') and ClassicalRegister ('readout').

📤 Expected Output

Named register diagram showing data[0], data[1], and ancilla[0] wires routing to readout classical bus.

💡 What Does This Demonstration Show?

Modular registers allow structuring large quantum circuits into dedicated functional units—such as data registers, syndrome extraction ancillas, and readout buses.

Course Learning Resource • Slide DeckLesson 810 Slides

Lesson 8: Two Qubits and Entanglement

Hadamard, CNOT, Bell-state intuition, and correlated quantum circuits.

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: How many basis states exist in a quantum register containing 8 qubits?

Question 2: How are multiple qubits initialized in Qiskit by default?

Question 3: What is the tensor product notation ⊗ used for in quantum registers?

Question 4: How many computational basis states exist for a 5-qubit quantum register?

Question 5: What is the difference between quantum registers (qubits) and classical registers (bits)?

Previous: Quantum Circuits: Visualizing Computation Next: Quantum Gates: Unitary Operators & Linear Algebra

1	# =========================================================
2	# Managing Quantum and Classical Registers in Qiskit
3	# Prepared for Google Colab (Run with Shift + Enter)
4	# =========================================================
5
6	# Step 1: Install required packages
7	!pip install qiskit
8
9	# Step 2: Import libraries
10	from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
11
12	# Step 3: Run Demonstration
13	# 1. Define named modular registers
14	data_reg = QuantumRegister(2, name='data') # 2 data qubits
15	ancilla_reg = QuantumRegister(1, name='ancilla') # 1 ancilla qubit
16	meas_reg = ClassicalRegister(3, name='readout') # 3 classical bits
17
18	# 2. Assemble circuit from registers
19	qc = QuantumCircuit(data_reg, ancilla_reg, meas_reg)
20	qc.h(data_reg[0]) # Gate on data qubit 0
21	qc.cx(data_reg[0], data_reg[1]) # Gate across data qubits
22	qc.cx(data_reg[1], ancilla_reg[0]) # Gate into ancilla
23	qc.measure(data_reg, meas_reg[0:2])
24	qc.measure(ancilla_reg[0], meas_reg[2])
25	print('Circuit with Named Registers:')
26	print(qc.draw('text'))