First time studying this topic?

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

Topic 5.3

Classical vs Quantum Computing: Side-by-Side Comparison

Contrast deterministic bits and Boolean logic with coherent qubits, unitary operations, and probabilistic measurement.

Learning Objectives

✓Compare bits (0 or 1) with qubits (superposition of |0> and |1>)
✓Contrast Boolean gates (AND, OR, NOT) with Unitary matrix gates (H, X, CNOT)
✓Understand the irreversible nature of measurement versus reversible unitary evolution

📖Let's Begin with a Story

Imagine reading a book. In a Classical Book, each page has words printed in black ink. Page 42 has a definite sentence that is either true or false. You can read it, put a bookmark in it, come back tomorrow, and Page 42 is still exactly the same. You can copy the page on a Xerox photocopier. In a Quantum Book, all the pages exist in a shimmering, translucent haze containing all possible stories simultaneously! As soon as your conscious eyes look at Page 42, the quantum haze instantly freezes (collapses) into one specific story, and all the other possible storylines vanish forever! Furthermore, the laws of quantum mechanics (the No-Cloning Theorem) forbid you from ever making an exact photocopy of that quantum page.

Why Should You Learn Classical vs Quantum Computing: Side-by-Side Comparison?

🎯 Practical & Engineering Stakes

Unlearning classical assumptions

To master quantum computing, you must discard classical intuitions: information cannot always be copied, gates must be reversible, and looking at data permanently alters it.

🎮 Fun Learning Zone

Grasp complex quantum concepts visually with zero prior physics or math knowledge!

Zero Prerequisites

Visual Concept Storyboard

The Dedicated Librarian vs. The Omnipresent Ghost

Classical LibrarianAvg: 500,000 checks

🚶‍♂️📖

Page-by-Page Inspection

Opens page 1, then page 2... checking 1 million names sequentially.

Quantum Ghost (Grover)Only 1,000 steps (√N)

👻✨

Parallel Interference

Reads all 1,000,000 pages at once; cancels 999,999 wrong names in silence!

Classical: Serial / ConstrainedQuantum: Coherent Wave Parallelism

Visual takeaway: Understand in 5 seconds

Everyday Analogy: The Dedicated Librarian vs. The Omnipresent Ghost

Imagine a library containing an unsorted phonebook of 1 million names, and you need to find who owns a specific phone number. A classical computer is like a very fast librarian who opens Page 1, checks the number, flips to Page 2, checks the number... on average checking 500,000 pages. A quantum computer is like an omnipresent ghost that enters the library: it reads every single page in the entire library in parallel, creates wave interference that cancels out the 999,999 wrong names, and leaves only the owner’s name glowing on the table!

🧪

Interactive Mental Sandbox

Try It Yourself

The 1-Million-Page Unsorted Search

Find 1 specific phone number in an unsorted directory.

🚶 Classical Librarian (O(N))

O(N/2)

Checks page 1, page 2, page 3... Takes hours to search 500,000 pages on average.

👻 Quantum Ghost (Grover: O(√N))

O(√N)

Reads all pages in superposition. Destructive wave interference cancels wrong names in just 1,000 steps! (500x faster).

📖 The Thought Experiment Prompt:“Think about adding light switches in your house. If you add 1 classical switch, you can store 1 bit (0 or 1). If you have 10 switches, you can store 10 bits. It grows additively: $10 + 1 = 11$. But with quantum qubits, every single qubit you add DOUBLES the entire capacity: 1 qubit = 2 states, 2 qubits = 4 states, 10 qubits = 1,024 states, 50 qubits = 1.125 quadrillion states! At 300 qubits, the number of simultaneous states ($2^{300}$) exceeds every atom in the observable universe!”

✨ The "Aha!" Moment

Classical power grows by addition (

n+1

); quantum power grows by exponential multiplication (

2^n

). Quantum computers do not replace classical computers—they solve problems whose state spaces exceed the physical universe!

What Is It?

Simple Explanation

Classical vs Quantum at a glance: - Classical Bit: A light switch. It is either OFF (0) or ON (1). - Quantum Qubit: A sphere. It can point to the North Pole (|0>), the South Pole (|1>), or anywhere on the surface (a blend of both!). - Classical Gates: Destroy information (e.g. 2 inputs go into an AND gate, but only 1 comes out; you cannot reverse it). - Quantum Gates: Reversible rotations of the sphere; zero information is ever lost until you measure!

Technical Explanation

Classical computing operates on deterministic Boolean logic functions

f: \{0, 1\}^n \rightarrow \{0, 1\}^m

. Quantum computing operates on pure state vectors

|\psi\rangle \in \mathbb{C}^2

evolved via unitary operator matrices

U \in U(2^n)

satisfying

U^\dagger U = I

. By Landauer's principle, irreversible classical gates dissipate heat (

k_B T \ln 2

), whereas unitary quantum evolution is dissipationless and reversible.

📚 Key Terms

No-Cloning Theorem

Simple: A fundamental law of physics: it is impossible to make an exact copy of an unknown quantum state.

Technical: Mathematical proof (Wootters, Zurek, Dieks 1982) stating that there exists no unitary transformation

U

such that

U|\psi\rangle|0\rangle = |\psi\rangle|\psi\rangle

for arbitrary

|\psi\rangle

Unitary Operator

Simple: A reversible quantum transformation that preserves the total probability of 100%.

Technical: A bounded linear operator

U

on a Hilbert space satisfying

U^\dagger U = U U^\dagger = I

, preserving inner products

\langle U\psi | U\phi \rangle = \langle \psi | \phi \rangle

$Reversibility$

Simple: Every quantum step can be run backwards to recover the exact starting state.

Technical: Unitary operations have well-defined inverse operators

U^{-1} = U^\dagger

Q-Sphere Lab: Classical vs Quantum Computing: Side-by-Side Comparison

IBM Q-Sphere Model

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

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

U^\dagger U = I, \quad \sum_{i=1}^{2^n} |\alpha_i|^2 = 1

What does it mean?

Unitary Reversibility & Conservation of Total Probability: Every quantum gate U has a perfect mathematical undo operation U† that runs computation backwards without losing energy or information, while the sum of all outcome probabilities is strictly locked at 100% (1.0).

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$U$	Unitary transformation matrix	A quantum logic gate or operation that rotates the quantum state vector
$U^\dagger$	Conjugate transpose (Hermitian adjoint)	The exact reverse or "Undo" button of the quantum gate
$I$	Identity matrix	The unchanged base state (equivalent to multiplying by 1)
$\|\alpha_i\|^2$	Born rule probability of outcome i	The percentage likelihood of reading state i upon measurement
$\sum \|\alpha_i\|^2 = 1$	Total probability normalization	All possibilities combined must always total exactly 100% (1.0)

📊 Numerical Example

Applying a Quantum NOT Gate (Pauli-X) to state |ψ⟩ = [0.6, 0.8]^T:

Step 1: Check Reversibility (X† × X = I): X = [[0, 1], [1, 0]], X† = [[0, 1], [1, 0]] X† × X = [[0×0 + 1×1, 0×1 + 1×0], [1×0 + 0×1, 1×1 + 0×0]] = [[1, 0], [0, 1]] = I ✓ Step 2: Apply Gate to Qubit: X

|\psi\rangle

= [[0, 1], [1, 0]] × [0.6, 0.8]^T = [0.8, 0.6]^T (flips amplitudes) Step 3: Verify Probability Conservation: P(0) + P(1) = |0.8|^2 + |0.6|^2 = 0.64 + 0.36 = 1.00 (100% conserved) ✓

Result: Operation is 100% reversible with zero information loss, and total probability remains exactly 1.00.

⚙️ How Does It Work?

Classical Bit Storage

Stored as presence (1) or absence (0) of ~10,000 electrons in a capacitor.

Quantum Qubit Storage

Stored as microscopic quantum degrees of freedom (electron spin up/down, superconducting flux).

Information Evolution

Classical uses non-reversible logic gates (NAND); quantum uses reversible unitary rotations.

🌍 Where Is It Used?

Ultra-Secure Quantum Key Distribution (QKD)

Problem: Eavesdroppers tapping fiber-optic cables without detection.

Solution: By the No-Cloning Theorem, any hacker attempting to copy or intercept quantum keys alters the state, instantly exposing their presence.

🎯 Try It Yourself

Can you write a quantum circuit that takes an unknown qubit |psi> and outputs two identical copies |psi>|psi>?

Interactive activity component

🐍 Python Hands-On: Proving Reversibility of Quantum Unitaries in Qiskit

Demonstrate that unlike irreversible classical gates (AND/OR), quantum gates are always reversible unitary matrices (U * U† = I).

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 from qiskit import QuantumCircuit
2 from qiskit.quantum_info import Operator, Statevector
3 import numpy as np

from qiskit import QuantumCircuit → Import circuit constructor

from qiskit.quantum_info import Operator, Statevector → Extract matrix operators and states

import numpy as np → Matrix math

3Demonstration Code & Logic

Python Execution Codepython

1 # 1. Demonstrate Reversibility of Hadamard: H * H = Identity
2 qc = QuantumCircuit(1)
3 qc.h(0)  # Put into superposition
4 sv_super = Statevector.from_instruction(qc)
5 print('After 1st Hadamard (Superposition):', sv_super.data.round(4))
6 qc.h(0)  # Apply Hadamard again to reverse
7 sv_restored = Statevector.from_instruction(qc)
8 print('After 2nd Hadamard (Restored):', sv_restored.data.round(4))
9  
10 # 2. Prove Operator is Unitary: U * U_dagger = I
11 op_h = Operator(QuantumCircuit(1).h(0))
12 u_matrix = op_h.data
13 identity_check = np.dot(u_matrix, u_matrix.conj().T)
14 print('\nHadamard Unitary Matrix:\n', u_matrix.round(3))
15 print('\nU * U† (Identity Matrix):\n', identity_check.round(3))
16 print('\nVerification: Quantum gates preserve total probability and have exact inverses.')

Step-by-Step Code Breakdown:

# 1. Demonstrate Reversibility of Hadamard: H * H = Identity

Hadamard reversibility

qc = QuantumCircuit(1)

Single qubit in |0>

qc.h(0) # Put into superposition

First H gate

sv_super = Statevector.from_instruction(qc)

Extract superposition

print('After 1st Hadamard (Superposition):', sv_super.data.round(4))

Amplitudes [0.7071, 0.7071]

qc.h(0) # Apply Hadamard again to reverse

Second H gate

sv_restored = Statevector.from_instruction(qc)

Extract restored state

print('After 2nd Hadamard (Restored):', sv_restored.data.round(4))

Exact [1.0, 0.0] restored

# 2. Prove Operator is Unitary: U * U_dagger = I

Unitary proof

op_h = Operator(QuantumCircuit(1).h(0))

Hadamard operator

u_matrix = op_h.data

Matrix elements

identity_check = np.dot(u_matrix, u_matrix.conj().T)

U * U^dagger

print('\nHadamard Unitary Matrix:\n', u_matrix.round(3))

Matrix

print('\nU * U† (Identity Matrix):\n', identity_check.round(3))

Identity check

print('\nVerification: Quantum gates preserve total probability and have exact inverses.')

Summary

📋 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 # Proving Reversibility of Quantum Unitaries in Qiskit
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 from qiskit import QuantumCircuit
11 from qiskit.quantum_info import Operator, Statevector
12 import numpy as np
13  
14 # Step 3: Run Demonstration
15 # 1. Demonstrate Reversibility of Hadamard: H * H = Identity
16 qc = QuantumCircuit(1)
17 qc.h(0)  # Put into superposition
18 sv_super = Statevector.from_instruction(qc)
19 print('After 1st Hadamard (Superposition):', sv_super.data.round(4))
20 qc.h(0)  # Apply Hadamard again to reverse
21 sv_restored = Statevector.from_instruction(qc)
22 print('After 2nd Hadamard (Restored):', sv_restored.data.round(4))
23  
24 # 2. Prove Operator is Unitary: U * U_dagger = I
25 op_h = Operator(QuantumCircuit(1).h(0))
26 u_matrix = op_h.data
27 identity_check = np.dot(u_matrix, u_matrix.conj().T)
28 print('\nHadamard Unitary Matrix:\n', u_matrix.round(3))
29 print('\nU * U† (Identity Matrix):\n', identity_check.round(3))
30 print('\nVerification: Quantum gates preserve total probability and have exact inverses.')

⚡ 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 Superposition

Apply Hadamard gate to transform |0> into |+>.

→

Reverse Transformation

Apply Hadamard gate again to reverse the state back to pure |0>.

→

Matrix Unitary Verification

Compute U * U† and verify that it equals the identity matrix, confirming zero information loss.

📥 Input / Initial State

QuantumCircuit(1) with sequential H gates.

📤 Expected Output

After 1st Hadamard: [0.7071, 0.7071]
After 2nd Hadamard: [1.0, 0.0]
U * U† = [[1, 0], [0, 1]]

💡 What Does This Demonstration Show?

Classical logic operations like AND/NAND lose information and dissipate heat (Landauer's Principle). Quantum circuits consist strictly of unitary transformations, meaning every quantum operation is mathematically reversible with zero fundamental entropy loss.

Course Learning Resource • Slide Deck19 Slides

Comprehensive Foundation in Quantum Computing

From Probability and Complex Numbers to Qubits, Interference, Entanglement, and Multi-Qubit Systems by Dr. Syed Muzamil Basha.

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: Which principle explains why classical logic gates like AND generate heat while quantum unitary gates are theoretically dissipationless?

Previous: History of Quantum Computing: From Theory to Silicon Next: What is Quantum Computing? The Core Model

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

1	# =========================================================
2	# Proving Reversibility of Quantum Unitaries in Qiskit
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	from qiskit import QuantumCircuit
11	from qiskit.quantum_info import Operator, Statevector
12	import numpy as np
13
14	# Step 3: Run Demonstration
15	# 1. Demonstrate Reversibility of Hadamard: H * H = Identity
16	qc = QuantumCircuit(1)
17	qc.h(0) # Put into superposition
18	sv_super = Statevector.from_instruction(qc)
19	print('After 1st Hadamard (Superposition):', sv_super.data.round(4))
20	qc.h(0) # Apply Hadamard again to reverse
21	sv_restored = Statevector.from_instruction(qc)
22	print('After 2nd Hadamard (Restored):', sv_restored.data.round(4))
23
24	# 2. Prove Operator is Unitary: U * U_dagger = I
25	op_h = Operator(QuantumCircuit(1).h(0))
26	u_matrix = op_h.data
27	identity_check = np.dot(u_matrix, u_matrix.conj().T)
28	print('\nHadamard Unitary Matrix:\n', u_matrix.round(3))
29	print('\nU * U† (Identity Matrix):\n', identity_check.round(3))
30	print('\nVerification: Quantum gates preserve total probability and have exact inverses.')