Module 1: Introduction to Quantum Computing¶

🎓 Learning Objectives

Understand quantum bits (qubits) and their properties
Master Dirac notation for quantum states
Learn single and multiple qubit gates
Understand the No Cloning Theorem
Explore quantum interference and its applications

Welcome to the first module of Quantum Computing & Machine Learning! This module introduces the fundamental building blocks of quantum computing. By the end of this module, you'll have a thorough understanding of qubits, quantum gates, Dirac notation, and the foundational principles that make quantum computing powerful.

Module Overview

This module covers the essential concepts that form the foundation of all quantum computing. You'll learn how quantum bits differ from classical bits, how to represent quantum states mathematically, and how quantum gates manipulate these states.

What is Quantum Computing?¶

Quantum computing harnesses the principles of quantum mechanics to process information in fundamentally different ways than classical computers. While classical computers use bits (0 or 1), quantum computers use quantum bits (qubits) that can exist in superposition of states.

Why Quantum Computing?

Quantum computing offers potential advantages for certain problems: - Factorization: Shor's algorithm can factor large numbers exponentially faster - Search: Grover's algorithm provides quadratic speedup for unstructured search - Simulation: Quantum systems can be simulated more efficiently - Optimization: Quantum algorithms can solve optimization problems faster

Key Difference from Classical Computing

Classical bits are either 0 or 1. Quantum bits can be in a superposition of both 0 and 1 simultaneously, enabling parallel computation on exponentially many states.

Quantum Bits (Qubits)¶

A quantum bit, or qubit, is the fundamental unit of quantum information. Unlike classical bits that can only be 0 or 1, qubits can exist in a superposition of both states.

Classical Bits vs Qubits¶

Let's understand the difference:

# Classical bit representation
classical_bit_0 = 0  # Can only be 0
classical_bit_1 = 1  # Can only be 1

# Qubit can be in superposition
# |ψ⟩ = α|0⟩ + β|1⟩
# where |α|² + |β|² = 1

Classical Bit: - State: Either 0 OR 1 - Measurement: Always deterministic - Copying: Can be copied perfectly

Qubit: - State: Superposition of |0⟩ and |1⟩ - Measurement: Probabilistic (collapses to |0⟩ or |1⟩) - Copying: Cannot be copied (No Cloning Theorem)

Visualizing Qubits¶

A qubit's state can be visualized on the Bloch Sphere:

        |0⟩ (North Pole)
           |
           |
    |+⟩ -- + -- |-⟩
           |
           |
        |1⟩ (South Pole)

Understanding the Bloch Sphere

|0⟩: Points to the north pole
|1⟩: Points to the south pole
|+⟩: Points to the equator (superposition)
|-⟩: Points to opposite side of equator
Any point on the sphere represents a valid qubit state

Qubit States in Python¶

Let's create and visualize qubit states using Qiskit:

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram
import numpy as np
import matplotlib.pyplot as plt

# Create a quantum circuit with 1 qubit
qc = QuantumCircuit(1)

# State |0⟩ - Classical 0 state
qc_0 = QuantumCircuit(1)
qc_0.initialize([1, 0], 0)  # |0⟩ = [1, 0]
print("|0⟩ state vector: [1, 0]")

# State |1⟩ - Classical 1 state
qc_1 = QuantumCircuit(1)
qc_1.initialize([0, 1], 0)  # |1⟩ = [0, 1]
print("|1⟩ state vector: [0, 1]")

# Superposition state |+⟩ = (|0⟩ + |1⟩)/√2
qc_plus = QuantumCircuit(1)
qc_plus.initialize([1/np.sqrt(2), 1/np.sqrt(2)], 0)
print("|+⟩ state vector: [1/√2, 1/√2]")

# Superposition state |-⟩ = (|0⟩ - |1⟩)/√2
qc_minus = QuantumCircuit(1)
qc_minus.initialize([1/np.sqrt(2), -1/np.sqrt(2)], 0)
print("|-⟩ state vector: [1/√2, -1/√2]")

# Visualize on Bloch sphere
simulator = Aer.get_backend('statevector_simulator')

# Visualize |+⟩ state
job = execute(qc_plus, simulator)
result = job.result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
plt.title("Bloch Sphere: |+⟩ State")
plt.show()

What Each State Represents:

|0⟩ = [1, 0]:
Classical 0 state
Measurement always gives 0
Probability: P(0) = 1, P(1) = 0
|1⟩ = [0, 1]:
Classical 1 state
Measurement always gives 1
Probability: P(0) = 0, P(1) = 1
|+⟩ = [1/√2, 1/√2]:
Equal superposition
Measurement: 50% chance of 0, 50% chance of 1
Probability: P(0) = 0.5, P(1) = 0.5
|-⟩ = [1/√2, -1/√2]:
Equal superposition with phase difference
Measurement: 50% chance of 0, 50% chance of 1
Phase difference affects interference

Measurement Collapse

When you measure a qubit in superposition, it collapses to either |0⟩ or |1⟩. The superposition is destroyed, and you can't recover it. This is a fundamental property of quantum mechanics.

Creating Superposition¶

The Hadamard gate creates superposition:

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram

# Create circuit: |0⟩ → H → |+⟩
qc = QuantumCircuit(1, 1)  # 1 qubit, 1 classical bit

# Apply Hadamard gate to create superposition
qc.h(0)

# Measure the qubit
qc.measure(0, 0)

# Simulate with multiple shots
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)

print(f"Measurement results: {counts}")
# Output: {'0': ~500, '1': ~500} (approximately equal)

# Visualize results
plot_histogram(counts)

What Happens: 1. Start with |0⟩ 2. Apply Hadamard gate: H|0⟩ = |+⟩ = (|0⟩ + |1⟩)/√2 3. Measure: 50% probability of 0, 50% probability of 1

Dirac Notation¶

Dirac notation (also called bra-ket notation) is the standard mathematical notation for quantum states. It was invented by physicist Paul Dirac.

Understanding Dirac Notation¶

Ket (|⟩): - Represents a quantum state vector - |0⟩ = column vector [1, 0] - |1⟩ = column vector [0, 1]

Bra (⟨|): - Represents the complex conjugate transpose - ⟨0| = row vector [1, 0] - ⟨1| = row vector [0, 1]

Bra-Ket (⟨|⟩): - Inner product (dot product) - ⟨0|0⟩ = 1 (normalized) - ⟨0|1⟩ = 0 (orthogonal)

Common Quantum States¶

import numpy as np

# |0⟩ state
ket_0 = np.array([1, 0])
print(f"|0⟩ = {ket_0}")

# |1⟩ state
ket_1 = np.array([0, 1])
print(f"|1⟩ = {ket_1}")

# |+⟩ = (|0⟩ + |1⟩)/√2
ket_plus = (ket_0 + ket_1) / np.sqrt(2)
print(f"|+⟩ = {ket_plus}")

# |-⟩ = (|0⟩ - |1⟩)/√2
ket_minus = (ket_0 - ket_1) / np.sqrt(2)
print(f"|-⟩ = {ket_minus}")

# General superposition: |ψ⟩ = α|0⟩ + β|1⟩
alpha = 0.6
beta = 0.8
# Normalize: |α|² + |β|² = 1
norm = np.sqrt(alpha**2 + beta**2)
alpha_norm = alpha / norm
beta_norm = beta / norm

ket_psi = alpha_norm * ket_0 + beta_norm * ket_1
print(f"|ψ⟩ = {alpha_norm:.3f}|0⟩ + {beta_norm:.3f}|1⟩")
print(f"Normalization check: |α|² + |β|² = {alpha_norm**2 + beta_norm**2:.3f}")

Inner Products and Orthogonality¶

# Bra-ket notation operations
def bra_ket(bra, ket):
    """Compute ⟨bra|ket⟩"""
    return np.dot(np.conj(bra), ket)

# ⟨0|0⟩ = 1
print(f"⟨0|0⟩ = {bra_ket(ket_0, ket_0)}")

# ⟨0|1⟩ = 0 (orthogonal)
print(f"⟨0|1⟩ = {bra_ket(ket_0, ket_1)}")

# ⟨+|+⟩ = 1 (normalized)
print(f"⟨+|+⟩ = {bra_ket(ket_plus, ket_plus)}")

# ⟨+|-⟩ = 0 (orthogonal)
print(f"⟨+|-⟩ = {bra_ket(ket_plus, ket_minus)}")

Orthonormal Basis

|0⟩ and |1⟩ form an orthonormal basis: - Orthogonal: ⟨0|1⟩ = 0 - Normalized: ⟨0|0⟩ = ⟨1|1⟩ = 1 - Any qubit state can be written as |ψ⟩ = α|0⟩ + β|1⟩

Multiple Qubits in Dirac Notation¶

For multiple qubits, we use tensor products:

# Two qubits: |00⟩, |01⟩, |10⟩, |11⟩
# |00⟩ = |0⟩ ⊗ |0⟩
ket_00 = np.kron(ket_0, ket_0)
print(f"|00⟩ = {ket_00}")

# |01⟩ = |0⟩ ⊗ |1⟩
ket_01 = np.kron(ket_0, ket_1)
print(f"|01⟩ = {ket_01}")

# |10⟩ = |1⟩ ⊗ |0⟩
ket_10 = np.kron(ket_1, ket_0)
print(f"|10⟩ = {ket_10}")

# |11⟩ = |1⟩ ⊗ |1⟩
ket_11 = np.kron(ket_1, ket_1)
print(f"|11⟩ = {ket_11}")

# Bell state: |Φ⁺⟩ = (|00⟩ + |11⟩)/√2
bell_plus = (ket_00 + ket_11) / np.sqrt(2)
print(f"|Φ⁺⟩ = {bell_plus}")

Tensor Product Notation

|ab⟩ = |a⟩ ⊗ |b⟩ (tensor product)
For n qubits, we have 2ⁿ basis states
2 qubits: 4 states (|00⟩, |01⟩, |10⟩, |11⟩)
3 qubits: 8 states (|000⟩, |001⟩, ..., |111⟩)

Single Qubit Gates¶

Quantum gates are operations that transform quantum states. They are represented by unitary matrices (operations that preserve the norm of the state vector).

Properties of Quantum Gates¶

Unitary: U†U = I (preserves probability)
Reversible: Every gate has an inverse
Linear: Gates act linearly on quantum states

Pauli Gates¶

The Pauli gates are fundamental single-qubit gates:

Pauli-X Gate (NOT Gate)¶

from qiskit import QuantumCircuit, Aer, execute
from qiskit.quantum_info import Operator
import numpy as np

# Pauli-X gate: |0⟩ → |1⟩, |1⟩ → |0⟩
qc = QuantumCircuit(1)
qc.x(0)  # Apply X gate

# Matrix representation
X = np.array([[0, 1],
              [1, 0]])
print("Pauli-X matrix:")
print(X)

# Verify: X|0⟩ = |1⟩
ket_0 = np.array([1, 0])
ket_1 = np.array([0, 1])
result = X @ ket_0
print(f"X|0⟩ = {result}")  # Should be [0, 1] = |1⟩

# Visualize
qc_init = QuantumCircuit(1)
qc_init.initialize([1, 0], 0)  # Start with |0⟩
qc_init.x(0)  # Apply X gate

simulator = Aer.get_backend('statevector_simulator')
job = execute(qc_init, simulator)
result = job.result()
statevector = result.get_statevector()
print(f"Final state: {statevector}")

Pauli-X Properties: - Flips |0⟩ to |1⟩ and vice versa - Classical NOT gate equivalent - X² = I (applying twice returns to original state)

Pauli-Y Gate¶

# Pauli-Y gate: Y = [[0, -i], [i, 0]]
Y = np.array([[0, -1j],
              [1j, 0]])
print("Pauli-Y matrix:")
print(Y)

# Y|0⟩ = i|1⟩
result = Y @ ket_0
print(f"Y|0⟩ = {result}")

Pauli-Y Properties: - Rotates around Y-axis of Bloch sphere - Introduces phase: Y|0⟩ = i|1⟩ - Y² = I

Pauli-Z Gate¶

# Pauli-Z gate: Z = [[1, 0], [0, -1]]
Z = np.array([[1, 0],
              [0, -1]])
print("Pauli-Z matrix:")
print(Z)

# Z|0⟩ = |0⟩, Z|1⟩ = -|1⟩
print(f"Z|0⟩ = {Z @ ket_0}")
print(f"Z|1⟩ = {Z @ ket_1}")

Pauli-Z Properties: - Phase flip: |1⟩ → -|1⟩ - |0⟩ unchanged - Z² = I

Pauli Gates Summary

Gate	Matrix	Effect	Classical Equivalent
X	[[0,1],[1,0]]	Bit flip	NOT
Y	[[0,-i],[i,0]]	Bit + Phase flip	-
Z	[[1,0],[0,-1]]	Phase flip	-

Hadamard Gate¶

The Hadamard gate creates superposition:

# Hadamard gate: H = (1/√2)[[1, 1], [1, -1]]
H = (1/np.sqrt(2)) * np.array([[1, 1],
                                [1, -1]])
print("Hadamard matrix:")
print(H)

# H|0⟩ = |+⟩ = (|0⟩ + |1⟩)/√2
result = H @ ket_0
print(f"H|0⟩ = {result}")
print(f"Expected: [1/√2, 1/√2] = [{1/np.sqrt(2):.3f}, {1/np.sqrt(2):.3f}]")

# H|1⟩ = |-⟩ = (|0⟩ - |1⟩)/√2
result = H @ ket_1
print(f"H|1⟩ = {result}")

# H² = I (applying twice returns to original)
print(f"H² = \n{H @ H}")

Hadamard Gate Properties: - Creates equal superposition - H|0⟩ = |+⟩, H|1⟩ = |-⟩ - H² = I (self-inverse)

Phase Gates¶

Phase gates introduce phase shifts:

# S gate (π/2 phase): S = [[1, 0], [0, i]]
S = np.array([[1, 0],
              [0, 1j]])
print("S gate (π/2 phase):")
print(S)

# T gate (π/4 phase): T = [[1, 0], [0, e^(iπ/4)]]
T = np.array([[1, 0],
              [0, np.exp(1j * np.pi / 4)]])
print("\nT gate (π/4 phase):")
print(T)

# Phase gate with arbitrary angle θ
def phase_gate(theta):
    return np.array([[1, 0],
                     [0, np.exp(1j * theta)]])

P_pi_3 = phase_gate(np.pi / 3)
print(f"\nPhase gate (π/3):")
print(P_pi_3)

Rotation Gates¶

Rotation gates rotate the qubit around axes on the Bloch sphere:

# Rotation around X-axis
def rx_gate(theta):
    return np.array([[np.cos(theta/2), -1j*np.sin(theta/2)],
                     [-1j*np.sin(theta/2), np.cos(theta/2)]])

# Rotation around Y-axis
def ry_gate(theta):
    return np.array([[np.cos(theta/2), -np.sin(theta/2)],
                     [np.sin(theta/2), np.cos(theta/2)]])

# Rotation around Z-axis
def rz_gate(theta):
    return np.array([[np.exp(-1j*theta/2), 0],
                     [0, np.exp(1j*theta/2)]])

# Example: Rotate π/2 around X-axis
RX_pi_2 = rx_gate(np.pi / 2)
print("RX(π/2) gate:")
print(RX_pi_2)

Complete Single Qubit Gate Example¶

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram

# Create a circuit demonstrating single-qubit gates
qc = QuantumCircuit(2, 2)  # 2 qubits, 2 classical bits

# Qubit 0: Demonstrate various gates
qc.x(0)      # Bit flip: |0⟩ → |1⟩
qc.h(0)      # Superposition: |1⟩ → |-⟩
qc.z(0)      # Phase flip
qc.s(0)      # π/2 phase
qc.t(0)      # π/4 phase

# Qubit 1: Create |+⟩ state
qc.h(1)

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

# Simulate
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)

print(f"Measurement results: {counts}")
plot_histogram(counts)

Gate Composition

You can combine gates to create any single-qubit operation. Any unitary operation on a qubit can be decomposed into rotations around X, Y, and Z axes.

Multiple Qubit Gates¶

Multi-qubit gates create entanglement and enable quantum algorithms. The most important is the CNOT gate.

CNOT Gate (Controlled-NOT)¶

The CNOT gate is a two-qubit gate that flips the target qubit if the control qubit is |1⟩:

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
import numpy as np

# CNOT gate matrix (4×4 for 2 qubits)
CNOT = np.array([[1, 0, 0, 0],   # |00⟩ → |00⟩
                 [0, 1, 0, 0],   # |01⟩ → |01⟩
                 [0, 0, 0, 1],   # |10⟩ → |11⟩
                 [0, 0, 1, 0]])  # |11⟩ → |10⟩
print("CNOT gate matrix:")
print(CNOT)

# Test CNOT on different input states
# |00⟩ → |00⟩
ket_00 = np.array([1, 0, 0, 0])
result = CNOT @ ket_00
print(f"CNOT|00⟩ = {result}")

# |10⟩ → |11⟩
ket_10 = np.array([0, 0, 1, 0])
result = CNOT @ ket_10
print(f"CNOT|10⟩ = {result}")

# Create Bell state using CNOT
qc = QuantumCircuit(2, 2)
qc.h(0)      # Create superposition on qubit 0
qc.cx(0, 1)  # CNOT: control=0, target=1
qc.measure([0, 1], [0, 1])

# Simulate
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)

print(f"\nBell state measurement: {counts}")
# Should see approximately equal |00⟩ and |11⟩
plot_histogram(counts)

CNOT Gate Truth Table:

Control	Target	Output Control	Output Target
0	0	0	0
0	1	0	1
1	0	1	1
1	1	1	0

CNOT Creates Entanglement

When you apply CNOT to a superposition state like |+⟩|0⟩, you create an entangled Bell state: - CNOT(|+⟩|0⟩) = (|00⟩ + |11⟩)/√2 = |Φ⁺⟩

Toffoli Gate (CCNOT)¶

The Toffoli gate is a three-qubit gate (controlled-controlled-NOT):

# Toffoli gate: flips target if both controls are |1⟩
qc = QuantumCircuit(3, 3)

# Test all combinations
test_cases = [
    ([0, 0, 0], "|000⟩"),
    ([0, 0, 1], "|001⟩"),
    ([0, 1, 0], "|010⟩"),
    ([0, 1, 1], "|011⟩"),
    ([1, 0, 0], "|100⟩"),
    ([1, 0, 1], "|101⟩"),
    ([1, 1, 0], "|110⟩ → |111⟩"),
    ([1, 1, 1], "|111⟩ → |110⟩"),
]

for state, description in test_cases:
    qc_new = QuantumCircuit(3)
    if state[0]: qc_new.x(0)
    if state[1]: qc_new.x(1)
    if state[2]: qc_new.x(2)

    qc_new.ccx(0, 1, 2)  # Toffoli: controls on 0,1; target on 2

    simulator = Aer.get_backend('statevector_simulator')
    job = execute(qc_new, simulator)
    result = job.result()
    statevector = result.get_statevector()

    print(f"{description}: {statevector}")

Toffoli Gate: - Universal for classical reversible computation - Only flips target when both controls are |1⟩ - Can be used to build any classical logic gate

Controlled Gates¶

Any single-qubit gate can be made controlled:

from qiskit import QuantumCircuit, Aer, execute

# Controlled-Z gate
qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.cz(0, 1)  # Controlled-Z: applies Z if control is |1⟩

# Controlled-Y gate
qc_cy = QuantumCircuit(2)
qc_cy.cy(0, 1)  # Controlled-Y

# Controlled-phase gate
qc_cp = QuantumCircuit(2)
qc_cp.cp(np.pi/4, 0, 1)  # Controlled-phase with angle π/4

# Controlled-U gate (arbitrary unitary)
from qiskit.quantum_info import random_unitary
U = random_unitary(2)
qc_cu = QuantumCircuit(2)
qc_cu.append(U.control(), [0, 1])  # Controlled-U

Controlled Gates Pattern

A controlled gate applies the operation to the target qubit only when the control qubit is |1⟩. This is fundamental for creating entanglement and conditional quantum operations.

SWAP Gate¶

The SWAP gate exchanges two qubits:

# SWAP gate: |ab⟩ → |ba⟩
qc = QuantumCircuit(2)
qc.x(0)      # Set qubit 0 to |1⟩
qc.swap(0, 1)  # Swap qubits 0 and 1

simulator = Aer.get_backend('statevector_simulator')
job = execute(qc, simulator)
result = job.result()
statevector = result.get_statevector()
print(f"After SWAP: {statevector}")
# Should be |10⟩ (qubit 1 is now |1⟩)

SWAP Gate: - Exchanges states of two qubits - Can be decomposed into 3 CNOT gates: SWAP = CNOT₁₂ CNOT₂₁ CNOT₁₂

No Cloning Theorem¶

The No Cloning Theorem is one of the most important results in quantum computing. It states that you cannot create an identical copy of an arbitrary unknown quantum state.

Understanding the Theorem¶

import numpy as np

# Attempt to clone an unknown state |ψ⟩ = α|0⟩ + β|1⟩
# We want: |ψ⟩|0⟩ → |ψ⟩|ψ⟩

# Let's see why this is impossible
def attempt_clone(alpha, beta):
    """
    Attempt to clone state |ψ⟩ = α|0⟩ + β|1⟩
    This function demonstrates why cloning is impossible
    """
    # Normalize
    norm = np.sqrt(alpha**2 + beta**2)
    alpha_norm = alpha / norm
    beta_norm = beta / norm

    # Original state: |ψ⟩ = α|0⟩ + β|1⟩
    psi = np.array([alpha_norm, beta_norm])

    # We want to create |ψ⟩|ψ⟩
    # But quantum mechanics doesn't allow this for arbitrary states!

    print(f"Original state: |ψ⟩ = {alpha_norm:.3f}|0⟩ + {beta_norm:.3f}|1⟩")
    print("Cannot create perfect copy: |ψ⟩|ψ⟩")
    print("This violates the linearity of quantum mechanics!")

# Try to clone different states
attempt_clone(1, 0)      # |0⟩ - this CAN be cloned
attempt_clone(0, 1)      # |1⟩ - this CAN be cloned
attempt_clone(1, 1)      # |+⟩ - this CANNOT be cloned perfectly

Proof Sketch¶

The No Cloning Theorem can be proven by contradiction:

Assume a cloning operation U exists: U|ψ⟩|0⟩ = |ψ⟩|ψ⟩
For two different states |ψ⟩ and |φ⟩:
U|ψ⟩|0⟩ = |ψ⟩|ψ⟩
U|φ⟩|0⟩ = |φ⟩|φ⟩
For superposition |χ⟩ = (|ψ⟩ + |φ⟩)/√2:
U|χ⟩|0⟩ should equal |χ⟩|χ⟩
But by linearity: U|χ⟩|0⟩ = (U|ψ⟩|0⟩ + U|φ⟩|0⟩)/√2 = (|ψ⟩|ψ⟩ + |φ⟩|φ⟩)/√2
This is NOT equal to |χ⟩|χ⟩ = (|ψ⟩ + |φ⟩)(|ψ⟩ + |φ⟩)/2
Contradiction! Therefore, no such U exists.

Implications¶

# What CAN be cloned:
# 1. Known states (we know the state, so we can prepare it)
qc_known = QuantumCircuit(2)
qc_known.h(0)  # We know this creates |+⟩, so we can prepare it again
qc_known.h(1)  # Clone by preparation

# 2. Orthogonal states (|0⟩ and |1⟩)
qc_orthogonal = QuantumCircuit(2)
qc_orthogonal.x(0)  # |0⟩ → |1⟩ (copying known state)

# What CANNOT be cloned:
# 1. Unknown arbitrary states
# 2. Superposition states (unless we know the coefficients)
# 3. Entangled states

No Cloning Theorem

You cannot create a perfect copy of an unknown quantum state. This has important implications: - Quantum error correction must work differently than classical - Quantum cryptography is secure (eavesdropping destroys the state) - Quantum teleportation is needed to transfer quantum states

What About Known States?

If you know the state, you can prepare it again (this is not cloning, it's preparation). The theorem only applies to unknown arbitrary states.

Quantum Error Correction Without Cloning¶

Since we can't clone, quantum error correction uses different techniques:

# Quantum error correction uses entanglement instead of cloning
# Example: 3-qubit bit-flip code

def encode_qubit(state):
    """Encode 1 qubit into 3 qubits using entanglement"""
    qc = QuantumCircuit(3)
    qc.initialize(state, 0)  # Original qubit
    qc.cx(0, 1)  # Entangle with qubit 1
    qc.cx(0, 2)  # Entangle with qubit 2
    return qc

# |0⟩ → |000⟩, |1⟩ → |111⟩ (not cloning, but encoding)
qc_encode_0 = encode_qubit([1, 0])
qc_encode_1 = encode_qubit([0, 1])

print("Error correction uses encoding, not cloning!")

Quantum Interference¶

Quantum interference is a phenomenon where probability amplitudes can add constructively or destructively, leading to enhanced or suppressed probabilities.

Understanding Interference¶

import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram

# Constructive interference: amplitudes add
# Destructive interference: amplitudes cancel

# Example 1: Constructive interference
qc_constructive = QuantumCircuit(2, 2)
qc_constructive.h(0)  # |0⟩ → |+⟩
qc_constructive.h(1)  # |0⟩ → |+⟩
# Both paths to |00⟩ have amplitude 1/√2
# Total amplitude: 1/√2 + 1/√2 = √2 (after normalization)
qc_constructive.measure([0, 1], [0, 1])

simulator = Aer.get_backend('qasm_simulator')
job = execute(qc_constructive, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc_constructive)
print("Constructive interference example:")
print(counts)

# Example 2: Destructive interference
qc_destructive = QuantumCircuit(2, 2)
qc_destructive.h(0)
qc_destructive.x(1)  # Flip qubit 1
qc_destructive.h(1)  # Creates |-⟩ on qubit 1
# Paths to |00⟩: one with +1/√2, one with -1/√2
# They cancel out: 1/√2 - 1/√2 = 0
qc_destructive.measure([0, 1], [0, 1])

job = execute(qc_destructive, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc_destructive)
print("\nDestructive interference example:")
print(counts)

Interference in Quantum Algorithms¶

Interference is crucial for quantum algorithms:

# Grover's algorithm uses interference to amplify the correct answer
def grover_interference_demo():
    """Demonstrate how interference amplifies the marked state"""
    qc = QuantumCircuit(3, 3)

    # Initialize all qubits in superposition
    for i in range(3):
        qc.h(i)

    # Oracle marks |111⟩ (this would be the search target)
    qc.cz(0, 1)
    qc.cz(1, 2)
    qc.x(2)
    qc.cz(0, 2)
    qc.x(2)

    # Diffusion operator (amplifies marked state via interference)
    for i in range(3):
        qc.h(i)
    for i in range(3):
        qc.x(i)
    qc.h(2)
    qc.cz(0, 2)
    qc.h(2)
    for i in range(3):
        qc.x(i)
    for i in range(3):
        qc.h(i)

    qc.measure([0, 1, 2], [0, 1, 2])

    simulator = Aer.get_backend('qasm_simulator')
    job = execute(qc, simulator, shots=1000)
    result = job.result()
    counts = result.get_counts(qc)

    print("Grover's algorithm - interference amplifies |111⟩:")
    print(counts)
    # Should see |111⟩ with high probability

grover_interference_demo()

Double-Slit Experiment Analogy¶

Quantum interference is similar to the double-slit experiment:

# Classical: Two paths, each with 50% probability
# Quantum: Two paths with amplitudes that interfere

def double_slit_analogy():
    """
    Analogous to double-slit experiment:
    - Two paths to the same outcome
    - Amplitudes interfere
    """
    # Path 1: |0⟩ → H → |+⟩ → measure → 50% |0⟩, 50% |1⟩
    # Path 2: |0⟩ → X → |1⟩ → H → |-⟩ → measure → 50% |0⟩, 50% |1⟩

    # But if we combine them with interference:
    qc = QuantumCircuit(1, 1)
    qc.h(0)      # Create superposition
    qc.z(0)      # Add phase (creates interference)
    qc.h(0)      # Second Hadamard (interference happens here)
    qc.measure(0, 0)

    simulator = Aer.get_backend('qasm_simulator')
    job = execute(qc, simulator, shots=1000)
    result = job.result()
    counts = result.get_counts(qc)

    print("Double-slit analogy - interference pattern:")
    print(counts)
    # HZH = X, so this should give |1⟩ with 100% probability

double_slit_analogy()

Interference is Key to Quantum Speedup

Quantum algorithms achieve speedup by: 1. Creating superposition (explore all possibilities) 2. Using interference to cancel wrong answers 3. Amplifying correct answers 4. Measuring the result

Complete Example: Building a Quantum Circuit¶

Let's put it all together:

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram, plot_circuit
import numpy as np

# Create a 3-qubit circuit demonstrating key concepts
qc = QuantumCircuit(3, 3)

# Qubit 0: Demonstrate superposition and phase
qc.h(0)      # |0⟩ → |+⟩
qc.z(0)      # Phase flip
qc.h(0)      # Interference: HZH = X, so |+⟩ → |1⟩

# Qubit 1: Create Bell state with qubit 2
qc.h(1)      # Create superposition
qc.cx(1, 2)  # Entangle qubits 1 and 2

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

# Visualize circuit
print("Quantum Circuit:")
print(qc.draw())

# Simulate
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)

print(f"\nMeasurement results: {counts}")
plot_histogram(counts)

# Analyze results
print("\nAnalysis:")
print("- Qubit 0: Should be |1⟩ (due to HZH = X)")
print("- Qubits 1,2: Should be entangled (|00⟩ or |11⟩)")

Practice Exercises¶

Exercise 1: Create Superposition¶

# Create a circuit that puts a qubit in the |+⟩ state and measures it
# Expected: ~50% |0⟩, ~50% |1⟩

qc = QuantumCircuit(1, 1)
# Your code here
qc.h(0)
qc.measure(0, 0)

simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)
print(counts)

Exercise 2: Bell State¶

# Create a Bell state |Φ⁺⟩ = (|00⟩ + |11⟩)/√2
# Expected: ~50% |00⟩, ~50% |11⟩, ~0% |01⟩, ~0% |10⟩

qc = QuantumCircuit(2, 2)
# Your code here
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()
counts = result.get_counts(qc)
print(counts)

Exercise 3: Gate Composition¶

# Show that HXH = Z
# Apply H, then X, then H to |0⟩ and verify it's equivalent to Z|0⟩

qc1 = QuantumCircuit(1)
qc1.h(0)
qc1.x(0)
qc1.h(0)

qc2 = QuantumCircuit(1)
qc2.z(0)

# Verify they produce the same state
simulator = Aer.get_backend('statevector_simulator')
job1 = execute(qc1, simulator)
job2 = execute(qc2, simulator)
state1 = job1.result().get_statevector()
state2 = job2.result().get_statevector()

print(f"HXH|0⟩ = {state1}")
print(f"Z|0⟩ = {state2}")
print(f"Are they equal? {np.allclose(state1, state2)}")

Key Takeaways¶

✅ Qubits can exist in superposition, unlike classical bits
✅ Dirac notation (|⟩ and ⟨|) is the standard way to represent quantum states
✅ Quantum gates are unitary operations that transform quantum states
✅ Single-qubit gates include Pauli gates (X, Y, Z), Hadamard (H), and phase gates
✅ Multi-qubit gates like CNOT create entanglement
✅ No Cloning Theorem prevents copying unknown quantum states
✅ Quantum interference enables quantum algorithms to achieve speedup

Next Steps¶

Continue to Module 2: Postulates of Quantum Computing to learn about: - Quantum state postulates - Quantum evolution - Quantum measurement - Bell's inequality - Quantum teleportation - Quantum error correction