Quantum Gates = Rotations

In classical computing:

• AND gate: Two inputs → One output (1 if both are 1)
• OR gate: Two inputs → One output (1 if either is 1)
• NOT gate: One input → Flip it (0→1, 1→0)

These are logic operations on bits.

A quantum gate is a rotation applied to a qubit's state on the Bloch sphere.

It doesn't "compute" like classical logic. It transforms the quantum state geometrically.

Think of it Like This:

Classical gate: "If input is 0, output 1. If input is 1, output 0."

Quantum gate: "Rotate the state vector 180° around the X-axis."

Same end result if measuring |0⟩ or |1⟩, but the quantum gate preserves superposition!

1. X Gate (Quantum NOT / Bit Flip)

What it does:

• Flips |0⟩ → |1⟩
• Flips |1⟩ → |0⟩
• Like classical NOT, but works on superposition too!

As a Rotation:

180° rotation around the X-axis of the Bloch sphere

Real-World Usage:

• Initialize qubits to |1⟩ (apply X to |0⟩)
• Invert states in algorithms
• Create controlled operations (CNOT uses X)

Example:

Start: |0⟩
Apply X gate
Result: |1⟩

Start: (|0⟩ + |1⟩)/√2  (superposition)
Apply X gate
Result: (|1⟩ + |0⟩)/√2  (still superposition, states flipped!)

🎮 Try it: Open Playground → Apply X to |0⟩ → See it flip to |1⟩

2. H Gate (Hadamard / Superposition Creator)

What it does:

• |0⟩ → |+⟩ = (|0⟩ + |1⟩)/√2 (equal superposition)
• |1⟩ → |−⟩ = (|0⟩ − |1⟩)/√2 (equal superposition with phase)
• Creates/destroys superposition

As a Rotation:

180° rotation around an axis halfway between X and Z

Real-World Usage:

• START of almost every quantum algorithm
• Create superposition to explore many possibilities
• Used in: Grover's search, Deutsch-Jozsa, Shor's algorithm
• Quantum teleportation

Example:

Start: |0⟩  (definite state)
Apply H gate
Result: (|0⟩ + |1⟩)/√2  (50/50 superposition)

Measure: 50% chance |0⟩, 50% chance |1⟩

🎮 Try it: Apply H to |0⟩ → See 50/50 probability distribution

3. Z Gate (Phase Flip)

What it does:

• Leaves |0⟩ unchanged: |0⟩ → |0⟩
• Adds a phase to |1⟩: |1⟩ → −|1⟩
• Doesn't change probabilities, but affects interference!

As a Rotation:

180° rotation around the Z-axis of the Bloch sphere

Real-World Usage:

• Control quantum interference patterns
• Used in Grover's algorithm (oracle marking)
• Phase kickback in quantum algorithms
• Building block for controlled operations

Example - The "Invisible" Gate:

Start: |1⟩
Apply Z gate
Result: −|1⟩

Measure: Still 100% chance of |1⟩! (Phase is invisible to measurement)

BUT in superposition:
Start: (|0⟩ + |1⟩)/√2
Apply Z
Result: (|0⟩ − |1⟩)/√2  (probabilities same, but interference changes!)

4. Y Gate (Combined Flip)

What it does:

• |0⟩ → i|1⟩ (flip to |1⟩ with imaginary phase)
• |1⟩ → −i|0⟩ (flip to |0⟩ with imaginary phase)
• Like X and Z combined

As a Rotation:

180° rotation around the Y-axis

Real-World Usage:

• Less common than X, Z, H
• Used in specific error correction schemes
• Some quantum simulation algorithms

Rotation Gates: Rx, Ry, Rz

• Rx(θ): Rotate θ degrees around X-axis
• Ry(θ): Rotate θ degrees around Y-axis
• Rz(θ): Rotate θ degrees around Z-axis

Example: Rx(90°) = half of an X gate rotation

Real-World Usage:

• Variational quantum algorithms (VQE, QAOA)
• Quantum machine learning
• Fine-tuning quantum states
• Optimizing circuits

Classical programming:

if (bit == 0) {
    output = 1;
} else {
    output = 0;
}

Quantum "programming":

Apply X gate  // Rotates state 180° around X-axis

// No if-else. The rotation happens to the ENTIRE quantum state,
// whether it's |0⟩, |1⟩, or superposition.

This is why quantum algorithms look so different from classical code!

Start: |0⟩
Apply H: (|0⟩ + |1⟩)/√2
Apply X: (|1⟩ + |0⟩)/√2  (same state, but flipped notation)
Apply H: |1⟩  (back to definite state!)

Result: Always |1⟩

Start: |0⟩
Apply H: (|0⟩ + |1⟩)/√2
Apply Z: (|0⟩ − |1⟩)/√2  (phase flip on |1⟩)
Apply H: |1⟩

Result: Always |1⟩

from qiskit import QuantumCircuit

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

# Apply gates
qc.h(0)     # Hadamard on qubit 0
qc.x(0)     # X gate on qubit 0
qc.z(0)     # Z gate on qubit 0
qc.ry(1.5, 0)  # Rotate 1.5 radians around Y-axis

# Measure
qc.measure_all()

# Run on simulator or real quantum computer
print(qc.draw())

🎯 Try These in the Playground:

1. H-H identity: Apply H twice to |0⟩ → Returns to |0⟩
2. X-X identity: Apply X twice → Returns to original state
3. Create |−⟩ state: Apply X, then H to |0⟩
4. Interference: H-X-H vs H-Z-H → Different results!
5. Phase effect: Compare H alone vs Z-H → See phase matter