Programming the Qubit

In classical computing, the most basic unit of software is the Gate.

• NOT: Turns a 0 to a 1.
• AND: Checks if two inputs are 1.
• OR: Checks if at least one input is 1.

In Quantum computing, we have Gates too, but they don't "Switch" bits. They Rotate the Bloch Sphere.

A Quantum Gate is a physical operation (like a Pulse of microwaves or a Laser beam) that changes the state of a Qubit in a precise, mathematical way. In this lesson, we will meet the "Mount Rushmore" of Quantum Gates.

---

1. The X-Gate (The Quantum NOT)

The X-Gate rotates the Qubit 180 degrees around the X-axis.

• If you start at $|0\rangle$ (North Pole), it flips you to $|1\rangle$ (South Pole).
• It is the most direct equivalent to the classical NOT gate.

2. The H-Gate (The Superposition Maker)

The Hadamard (H) Gate is the most important gate for Quantum Speedup.

• It takes a "Pillar" state ($|0\rangle$ or $|1\rangle$) and rotates it to the Equator.
• It creates a perfect 50/50 superposition.
• Without the H-Gate, a Quantum computer is just a very cold, very expensive classical computer.

3. The Z-Gate (The Phase Shifter)

The Z-Gate rotates the Qubit around the Z-axis (Longitude).

• It doesn't change the 0/1 probability!
• It just changes the "Direction" of the wave.
• This is how we set up Interference patterns to cancel out wrong answers.

4. The CNOT Gate (The Entangler)

The Controlled-NOT (CNOT) involves Two Qubits.

• It says: "IF Qubit 1 is $|1\rangle$, THEN flip Qubit 2. Otherwise, do nothing."
• If the first Qubit is in Superposition, the two Qubits become Entangled.
• This is how we "Wire" Qubits together to share information.

graph LR
    A[Qubit A: CONTROL] -- "If |1>" --> B{CNOT GATE}
    C[Qubit B: TARGET] -- "Flip State" --> B
    B --> D[Result: ENTANGLED PAIR]
    style B fill:#00f,stroke:#fff,color:#fff

---

5. Summary: Gates as Tools

Think of a Quantum Gate as a Chisel. You start with a raw block of "Probability" (a set of 0s).

1. Use the H-Gate to turn it into a "Cloud" (Superposition).
2. Use X and Z Gates to shape the cloud.
3. Use CNOT Gates to connect the parts.
4. The result is a specialized "Waveform" that holds your answer.

---

Exercise: The "Gate Sequence"

1. The Task: You have a $|0\rangle$ qubit. Run this sequence: H -> X -> H.
2. Visual Logic:
   • H: Now you're on the Equator (facing front).
   • X: You flip 180 degrees (now facing back).
   • H: You rotate back to the poles.
3. The Result: You end up at $|0\rangle$. (Math: $H \cdot X \cdot H = Z$).
4. Reflect: You just "Programmed" a Qubit!

Conceptual Code (The 'Gate' Simulator in Qiskit):

# A look at standard Quantum Assembly (OpenQASM) logic
# qreg q[1]; // Define 1 qubit
# creg c[1]; // Define 1 classical bit for measurement

# h q[0];     // Put it in superposition
# x q[0];     // Flip it
# z q[0];     // Change its phase
# measure q[0] -> c[0]; // Slap the coin!

Reflect: Are you using "Fixed Logic" (Boolean) or "Flexible Logic" (Quantum Rotations) for your strategy?