First time studying this topic?

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

Topic 6.1

Quantum Circuits: Visualizing Computation

Learn how quantum computations are drawn and structured as quantum circuit diagrams: wires, gates, and time flow.

Learning Objectives

✓Read quantum circuit diagrams from left to right (chronological time)
✓Understand quantum wires as physical qubits and double wires as classical bits
✓Map graphical circuit diagrams directly to linear algebra matrix equations

📖Let's Begin with a Story

In classical electronics, electrical engineers draw schematic circuit diagrams using wires, resistors, and transistors. Electrons flow through physical copper wires from a power source to a ground. In quantum computing, we also draw "circuits"—but there is a crucial difference! In a quantum circuit diagram, the horizontal lines (wires) do NOT represent physical wires moving through space. They represent time! A horizontal line represents a single qubit progressing forward in time from left to right. When a box labeled "H" or "X" sits on that line, it means: "At this exact microsecond in time, fire a calibrated laser or microwave pulse at this qubit to rotate its state."

Why Should You Learn Quantum Circuits: Visualizing Computation?

🎯 Practical & Engineering Stakes

The sheet music of quantum mechanics

Circuit diagrams are the universal visual language of quantum software. Whether in IBM Quantum Composer, Qiskit, Cirq, or Pennylane, every quantum algorithm is composed and visualized as a circuit.

What Is It?

Simple Explanation

Reading a quantum circuit is like reading sheet music: 1. Horizontal Wires: The instruments (qubits). Time flows from left to right. 2. Boxes on Wires: The musical notes (quantum gates). They tell the qubit what dance move to make. 3. Black Meter Symbols: The finale (measurement). Checking the instrument at the end to hear what note it settled on. 4. Double Lines: Ordinary classical wires carrying 0s and 1s after measurement.

Technical Explanation

A quantum circuit is an acyclic directed computational network over

n

quantum wires and

m

classical registers. The circuit depth

D

denotes the length of the critical path of sequential gate operations, directly constrained by qubit coherence time

D \cdot t_{gate} \ll T_2

. The circuit width equals the number of allocated qubits

n

📚 Key Terms

Quantum Wire

Simple: A line representing one qubit traveling forward through time.

Technical: An allocated 2-level quantum subsystem preserving state

|\psi(t)\rangle

over operational duration.

Circuit Depth

Simple: How many layers of gates are stacked from start to finish.

Technical: The maximum length of a path of dependent quantum gates from input to measurement.

Circuit Width

Simple: How many total qubits are used in the circuit.

Technical: The total number of operational qubits participating in the circuit.

Q-Sphere Lab: Quantum Circuits: Visualizing Computation

IBM Q-Sphere Model

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

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_{\text{final}}\rangle = U_k \dots U_2 U_1 |0\rangle^{\otimes n}

What does it mean?

Chronological Gate Ordering in Quantum Circuits: In a circuit diagram, quantum gates are read from left to right like notes on a music score. However, in linear algebra, matrix operations are written from right to left! The first gate applied (

U_1

) acts on the initial ground state first, followed sequentially by

U_2

up to

U_k

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$\|0\rangle^{\otimes n}$	Initial ground state of $n$ qubits	All $n$ qubits initialized to standard zero $\|00\dots 0\rangle$
$U_1$	First gate applied chronologically	The first physical pulse acting on the initial state
$U_2 \dots U_k$	Subsequent quantum gates	Sequential unitary matrix operations applied in order
$\|\psi_{\text{final}}\rangle$	Final output state vector	The resulting multi-qubit state ready for readout measurement

📊 Numerical Example

Tracing a 1-qubit circuit with two gates: first Hadamard (H), then Pauli-X (X):

Initial State:

|0\rangle

= [1, 0]^T Step 1: Apply first gate U1 = H (creates equal superposition):

|\psi1\rangle

= H

|0\rangle

= [1/√2, 1/√2]^T = (

|0\rangle

|1\rangle

)/√2 Step 2: Apply second gate U2 = X (flips amplitudes): |ψ_final⟩ = X

|\psi1\rangle

= [[0, 1], [1, 0]] × [1/√2, 1/√2]^T = [1/√2, 1/√2]^T Notice matrix product order: |ψ_final⟩ = (X · H)

|0\rangle

= X(H

|0\rangle

)

Result: Reading left-to-right on a wire translates to multiplying matrices right-to-left: X · H $|0\rangle$ .

⚙️ How Does It Work?

Left Margin (Initialization)

All qubits are prepared in standard ground state |0>.

Middle (Unitary Gates)

Single-qubit gates rotate individual wires; two-qubit gates link adjacent wires.

Right Margin (Measurement)

Meter icons project qubits, writing classical bits to double wires.

🌍 Where Is It Used?

IBM Quantum Composer

Problem: Allowing students and researchers to build quantum circuits graphically in a web browser.

Solution: Drag-and-drop circuit interface automatically synthesizes OpenQASM and executes on real quantum hardware.

🎯 Try It Yourself

In a quantum circuit, if an X gate appears to the LEFT of a Z gate on the same wire, in which order are the matrix operations multiplied against the state vector?

Interactive activity component

🐍 Python Hands-On: Constructing and Drawing Quantum Circuits in Qiskit

Create a multi-qubit circuit with Hadamard and CNOT gates, and generate visual ASCII circuit diagrams with 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 qiskit-aer

Packages:

qiskitqiskit-aer

2Import Libraries

Import Statementspython

1 from qiskit import QuantumCircuit
2 from qiskit.quantum_info import Statevector

from qiskit import QuantumCircuit → Core class to assemble quantum circuits

from qiskit.quantum_info import Statevector → Simulate exact quantum state

3Demonstration Code & Logic

Python Execution Codepython

1 # 1. Initialize a 2-qubit, 2-classical-bit circuit
2 qc = QuantumCircuit(2, 2)
3 qc.h(0)            # Put qubit 0 into superposition
4 qc.cx(0, 1)        # Entangle qubit 1 with qubit 0
5 qc.measure([0, 1], [0, 1])  # Measure both qubits
6  
7 # 2. Draw Circuit Diagram with Qiskit draw()
8 print('=== Qiskit Quantum Circuit Diagram ===')
9 print(qc.draw('text'))
10  
11 # 3. Inspect Circuit Properties
12 print(f'\nCircuit Width  : {qc.num_qubits} qubits, {qc.num_clbits} classical bits')
13 print(f'Circuit Depth  : {qc.depth()} gate layers')
14 print(f'Gate Operations: {dict(qc.count_ops())}')

Step-by-Step Code Breakdown:

# 1. Initialize a 2-qubit, 2-classical-bit circuit

Constructor

qc = QuantumCircuit(2, 2)

Allocate 2 qubits (q0, q1) and 2 classical bits (c0, c1)

qc.h(0) # Put qubit 0 into superposition

Apply Hadamard

qc.cx(0, 1) # Entangle qubit 1 with qubit 0

Apply CNOT

qc.measure([0, 1], [0, 1]) # Measure both qubits

Add measurement operations

# 2. Draw Circuit Diagram with Qiskit draw()

Circuit drawing

print('=== Qiskit Quantum Circuit Diagram ===')

Header

print(qc.draw('text'))

Generate text-based circuit layout

# 3. Inspect Circuit Properties

Circuit metadata

print(f'\nCircuit Width : {qc.num_qubits} qubits, {qc.num_clbits} classical bits')

Dimensions

print(f'Circuit Depth : {qc.depth()} gate layers')

Layers

print(f'Gate Operations: {dict(qc.count_ops())}')

Gate inventory

📋 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 # Constructing and Drawing Quantum Circuits 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.quantum_info import Statevector
12  
13 # Step 3: Run Demonstration
14 # 1. Initialize a 2-qubit, 2-classical-bit circuit
15 qc = QuantumCircuit(2, 2)
16 qc.h(0)            # Put qubit 0 into superposition
17 qc.cx(0, 1)        # Entangle qubit 1 with qubit 0
18 qc.measure([0, 1], [0, 1])  # Measure both qubits
19  
20 # 2. Draw Circuit Diagram with Qiskit draw()
21 print('=== Qiskit Quantum Circuit Diagram ===')
22 print(qc.draw('text'))
23  
24 # 3. Inspect Circuit Properties
25 print(f'\nCircuit Width  : {qc.num_qubits} qubits, {qc.num_clbits} classical bits')
26 print(f'Circuit Depth  : {qc.depth()} gate layers')
27 print(f'Gate Operations: {dict(qc.count_ops())}')

⚡ 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

Initialize Circuit

Allocate quantum and classical registers in QuantumCircuit(2, 2).

→

Attach Gates

Apply H(0) and CNOT(0, 1) to construct the Bell state.

→

Draw & Analyze

Generate text diagram with qc.draw('text') and inspect circuit depth and gate counts.

📥 Input / Initial State

QuantumCircuit(2, 2) with H, CX, and Measure gates.

📤 Expected Output

q_0: ──■───────[ M ]
     │  ║
q_1: ──X───────[ M ]
     ║  ║
Depth: 2 | Ops: {'measure': 2, 'h': 1, 'cx': 1}

💡 What Does This Demonstration Show?

A quantum circuit diagram represents quantum algorithms as horizontal qubit timelines evolving from left to right through discrete unitary gates, culminating in classical measurement.

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: What do the double lines (═) in a quantum circuit diagram represent?

Question 2: In quantum circuit diagrams, what does time flow represent?

Question 3: What does circuit depth measure?

Question 4: How are multiple quantum gates composed mathematically?

Question 5: What do double lines (classical wires) in quantum circuits represent?

Previous: Quantum Computing Limitations & The Road Ahead Next: Quantum Registers & Multi-Qubit State Vectors

1	from qiskit import QuantumCircuit
2	from qiskit.quantum_info import Statevector

1	# =========================================================
2	# Constructing and Drawing Quantum Circuits 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.quantum_info import Statevector
12
13	# Step 3: Run Demonstration
14	# 1. Initialize a 2-qubit, 2-classical-bit circuit
15	qc = QuantumCircuit(2, 2)
16	qc.h(0) # Put qubit 0 into superposition
17	qc.cx(0, 1) # Entangle qubit 1 with qubit 0
18	qc.measure([0, 1], [0, 1]) # Measure both qubits
19
20	# 2. Draw Circuit Diagram with Qiskit draw()
21	print('=== Qiskit Quantum Circuit Diagram ===')
22	print(qc.draw('text'))
23
24	# 3. Inspect Circuit Properties
25	print(f'\nCircuit Width : {qc.num_qubits} qubits, {qc.num_clbits} classical bits')
26	print(f'Circuit Depth : {qc.depth()} gate layers')
27	print(f'Gate Operations: {dict(qc.count_ops())}')