First time studying this topic?

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

Topic 6.10

Measurement in Quantum Circuits: Projection & Classical Registers

Understand how measurements are sequenced in circuits: mid-circuit measurement, deferred measurement principle, and classical conditioning.

Learning Objectives

✓Sequence measurements into classical register bits
✓Understand the Principle of Deferred Measurement
✓Explore mid-circuit measurement and dynamic quantum circuits (feed-forward)

📖Let's Begin with a Story

For decades, quantum computing followed a rigid textbook rule: "Perform all quantum gate rotations first, and only measure at the very end of the circuit." In 2021, quantum hardware engineers unlocked a dramatic capability: Mid-Circuit Measurement and Reset (MCMR). Now, you can pause in the middle of a quantum calculation, measure a single qubit, read its classical 0 or 1 result, and conditionally fire a microwave pulse to adjust other qubits based on that measurement! This dynamic feed-forward capability is the essential prerequisite for real-time quantum error correction, allowing chips to catch and fix errors while the calculation is actively running.

Why Should You Learn Measurement in Quantum Circuits: Projection & Classical Registers?

🎯 Practical & Engineering Stakes

Dynamic circuits

Mid-circuit measurement reduces required qubit counts and powers fault-tolerant quantum error correction. Understanding how measurement interfaces with classical control logic is modern state of the art.

What Is It?

Simple Explanation

Measurement is the exit door of the quantum world: - The meter icon [ M ] takes a qubit and looks at it. - The delicate quantum state collapses into a regular 0 or 1. - That 0 or 1 is written onto a double wire (classical bit). - You can even use that 0 or 1 to decide what move to make next (Dynamic Circuits)!

Technical Explanation

Projective measurement on qubit

j

applies projection operators

P_0 = I \otimes |0\rangle\langle 0| \otimes I

and

P_1 = I \otimes |1\rangle\langle 1| \otimes I

. The Principle of Deferred Measurement (Nielsen & Chuang) proves that any mid-circuit measurement followed by classically conditioned gates is computationally equivalent to deferring the measurement to the end of the circuit using coherent quantum controlled gates.

📚 Key Terms

Principle of Deferred Measurement

Simple: A math rule proving that measuring in the middle of a circuit can always be moved to the very end without changing the answer.

Technical: Theorem establishing that measurement operations commute with control lines when replaced by coherent quantum control gates.

Mid-Circuit Measurement (MCMR)

Simple: Measuring a qubit in the middle of a computation to fix errors or reuse the qubit.

Technical: Executing non-terminal projective measurement and active reset within coherence time window

t < T_2

Q-Sphere Lab: Measurement in Quantum Circuits: Projection & Classical Registers

IBM Q-Sphere Model

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

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

P(q_0 = 0) = |\alpha_{00}|^2 + |\alpha_{01}|^2, \quad |\psi_{\text{collapsed}}\rangle = \frac{\alpha_{00}|00\rangle + \alpha_{01}|01\rangle}{\sqrt{|\alpha_{00}|^2 + |\alpha_{01}|^2}}

What does it mean?

Partial Measurement & Partial Wavefunction Collapse: When you measure only ONE qubit in an n-qubit register (e.g. measuring qubit 0), you sum the squared amplitudes of all basis states where that qubit is 0. The unmeasured qubits remain in quantum superposition, but the measured qubit snaps into a classical bit!

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$P(q_0 = 0)$	Probability qubit 0 collapses to 0	Sum of probabilities of all states with 0 in the first position
$\alpha_{00}, \alpha_{01}$	Amplitudes of compatible states	Weights of states $\|00\rangle$ and $\|01\rangle$ where $q_0 = 0$
$\|\psi_{\text{collapsed}}\rangle$	Partial collapsed state vector	The remaining quantum state for the other unmeasured qubits
$\sqrt{\dots}$	Renormalization denominator	Restores total probability back to 100% (1.0)

📊 Numerical Example

Measuring qubit 0 on state |ψ⟩ = 0.5|00⟩ + 0.5|01⟩ + 0.707|10⟩:

Step 1: Identify states where Qubit 0 is "0":

|00\rangle

has amplitude 0.5 → P = (0.5)^2 = 0.25

|01\rangle

has amplitude 0.5 → P = (0.5)^2 = 0.25 Step 2: Total probability Qubit 0 is "0": P(q0 = 0) = 0.25 + 0.25 = 0.50 (50%) Step 3: Calculate Post-Measurement State if outcome is "0": |ψ_collapsed⟩ = (0.5

|00\rangle

+ 0.5

|01\rangle

) / √0.50 = (0.5 / 0.7071)

|00\rangle

+ (0.5 / 0.7071)

|01\rangle

= (1/√2)

|00\rangle

+ (1/√2)

|01\rangle

|0\rangle

⊗ [(

|0\rangle

|1\rangle

)/√2]

Result: Qubit 0 is now definitely classical 0, while Qubit 1 remains in an equal 50/50 superposition.

⚙️ How Does It Work?

Gate Execution

Complete coherent unitary operations.

Projective Collapse

Coupled readout resonator collapses selected qubit.

Classical Register Storage

Write binary bit string into classical register c[0], c[1]... for host computer analysis.

🌍 Where Is It Used?

Quantum Error Correction (Syndrome Extraction)

Problem: Detecting bit-flips without destroying the stored quantum data.

Solution: Mid-circuit measurements read ancilla qubits to detect error locations while data qubits remain in superpositions.

🎯 Try It Yourself

According to the Principle of Deferred Measurement, can a mid-circuit measurement always be replaced by moving the measurement to the end of the circuit?

Interactive activity component

🐍 Python Hands-On: Simulating Mid-Circuit and Terminal Measurement in Qiskit

Assemble quantum circuits with classical registers and simulate measurement readouts using AerSimulator.

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 qiskit-aer

Packages:

qiskitqiskit-aer

2Import Libraries

Import Statementspython

1 from qiskit import QuantumCircuit
2 from qiskit_aer import AerSimulator

from qiskit import QuantumCircuit → Circuit constructor

from qiskit_aer import AerSimulator → Aer simulator

3Demonstration Code & Logic

Python Execution Codepython

1 # 1. Build circuit with H, CNOT and Measurement
2 qc = QuantumCircuit(2, 2)
3 qc.h(0)
4 qc.cx(0, 1)
5 qc.measure([0, 1], [0, 1])  # Map q0 -> c0, q1 -> c1
6 print('Circuit Diagram with Measurement Gauges:')
7 print(qc.draw('text'))
8  
9 # 2. Execute 1,024 measurement shots on AerSimulator
10 sim = AerSimulator()
11 counts = sim.run(qc, shots=1024).result().get_counts()
12 print('\nMeasurement Readout (1,024 shots):')
13 for outcome, freq in counts.items():
14     pct = (freq / 1024) * 100
15     print(f'  State \'{outcome}\' : {freq} shots ({pct:.1f}%)')

Step-by-Step Code Breakdown:

# 1. Build circuit with H, CNOT and Measurement

Circuit setup

qc = QuantumCircuit(2, 2)

2 qubits, 2 classical bits

qc.h(0)

Superposition on control

qc.cx(0, 1)

CNOT to entangle

qc.measure([0, 1], [0, 1]) # Map q0 -> c0, q1 -> c1

Measurement mapping

print('Circuit Diagram with Measurement Gauges:')

Label

print(qc.draw('text'))

Print diagram

# 2. Execute 1,024 measurement shots on AerSimulator

Run simulation

sim = AerSimulator()

Initialize simulator

counts = sim.run(qc, shots=1024).result().get_counts()

Run shots

print('\nMeasurement Readout (1,024 shots):')

Readout header

for outcome, freq in counts.items():

Print results

pct = (freq / 1024) * 100

Calculate percent

print(f' State \'{outcome}\' : {freq} shots ({pct:.1f}%)')

Print row

📋 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 Mid-Circuit and Terminal Measurement in Qiskit
3 # Prepared for Google Colab (Run with Shift + Enter)
4 # =========================================================
5  
6 # Step 1: Install required packages
7 !pip install qiskit qiskit-aer
8  
9 # Step 2: Import libraries
10 from qiskit import QuantumCircuit
11 from qiskit_aer import AerSimulator
12  
13 # Step 3: Run Demonstration
14 # 1. Build circuit with H, CNOT and Measurement
15 qc = QuantumCircuit(2, 2)
16 qc.h(0)
17 qc.cx(0, 1)
18 qc.measure([0, 1], [0, 1])  # Map q0 -> c0, q1 -> c1
19 print('Circuit Diagram with Measurement Gauges:')
20 print(qc.draw('text'))
21  
22 # 2. Execute 1,024 measurement shots on AerSimulator
23 sim = AerSimulator()
24 counts = sim.run(qc, shots=1024).result().get_counts()
25 print('\nMeasurement Readout (1,024 shots):')
26 for outcome, freq in counts.items():
27     pct = (freq / 1024) * 100
28     print(f'  State \'{outcome}\' : {freq} shots ({pct:.1f}%)')

⚡ 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

Create Entangled Pair

Prepare (|00> + |11>)/sqrt(2).

→

Attach Readout Gauges

Map quantum state collapse onto classical bit registers.

→

Sample 1,024 Shots

Observe identical bit outcomes ('00' and '11') with zero cross-terms.

📥 Input / Initial State

QuantumCircuit(2, 2) with Bell state and measurement.

📤 Expected Output

State '00': ~512 shots (50.0%)
State '11': ~512 shots (50.0%)
State '01': 0 shots
State '10': 0 shots

💡 What Does This Demonstration Show?

Measurement converts continuous quantum probability amplitudes into discrete classical bitstrings. The perfect agreement between bit 0 and bit 1 confirms entanglement.

Course Learning Resource • Slide DeckLesson 311 Slides

Lesson 3: Quantum Measurement with a One-Qubit Circuit

Hadamard gate, quantum registers, simulation, and histogram measurement.

Author: Dr. Syed Muzamil Basha• FDP Approved Curriculum

Open in New Tab

Available Slide Decks:

📝 Learning Check

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

Question 1: Why do quantum cloud platforms (like IBM Quantum) run circuits for multiple "shots" (e.g. 1,024 or 4,096 shots) rather than executing once?

Question 2: What happens to a qubit immediately after measurement?

Question 3: If you measure |ψ⟩ = 0.8|0⟩ + 0.6|1⟩, what is the probability of outcome "0"?

Question 4: Can you measure a qubit without destroying its superposition?

Question 5: In Qiskit, what do the measure gates (meter symbols) do in a circuit?

Previous: The CNOT Gate: Entanglement & The XOR Truth Table Next: Building Quantum Circuits in Code: Qiskit Syntax

1	from qiskit import QuantumCircuit
2	from qiskit_aer import AerSimulator

1	# =========================================================
2	# Simulating Mid-Circuit and Terminal Measurement in Qiskit
3	# Prepared for Google Colab (Run with Shift + Enter)
4	# =========================================================
5
6	# Step 1: Install required packages
7	!pip install qiskit qiskit-aer
8
9	# Step 2: Import libraries
10	from qiskit import QuantumCircuit
11	from qiskit_aer import AerSimulator
12
13	# Step 3: Run Demonstration
14	# 1. Build circuit with H, CNOT and Measurement
15	qc = QuantumCircuit(2, 2)
16	qc.h(0)
17	qc.cx(0, 1)
18	qc.measure([0, 1], [0, 1]) # Map q0 -> c0, q1 -> c1
19	print('Circuit Diagram with Measurement Gauges:')
20	print(qc.draw('text'))
21
22	# 2. Execute 1,024 measurement shots on AerSimulator
23	sim = AerSimulator()
24	counts = sim.run(qc, shots=1024).result().get_counts()
25	print('\nMeasurement Readout (1,024 shots):')
26	for outcome, freq in counts.items():
27	pct = (freq / 1024) * 100
28	print(f' State \'{outcome}\' : {freq} shots ({pct:.1f}%)')