quantumDay 1

Day 1: Quantum Computing Landscape & Qubit Fundamentals

January 20, 20267 min read

Day 1 of the quantum rabbit hole. I came in knowing that quantum computers are "powerful" and use "qubits instead of bits." That's about the depth of understanding most people have. Today I wanted to go deeper — understand why they're different, who's building them, and actually run code on a quantum simulator.

Classical vs. Quantum: The Real Difference

The difference between classical and quantum computing isn't just "faster." It's a fundamentally different model of computation.

Classical computers use bits — 0 or 1. Every operation is deterministic. Same input, same output, every time. A 64-bit processor can be in exactly one of 2^64 states at any given moment.

Quantum computers use qubits, and three properties make them work:

Superposition — A qubit can exist in a combination of |0⟩ and |1⟩ simultaneously. Not "we don't know which one it is" — it's genuinely in both states at once, described by probability amplitudes.
Entanglement — Two qubits can be correlated in ways that have no classical equivalent. Measure one, and the other's state is instantly determined. Einstein called it "spooky action at a distance."
Interference — Quantum algorithms amplify the probability of correct answers and cancel out wrong ones. This is the actual secret sauce that makes quantum algorithms work.

Common misconception: "quantum = tries all answers simultaneously." That's misleading. You can't read out all the parallel states. When you measure, you get one result. The trick is designing algorithms that use interference to make the right answer the most probable.

Quantum won't replace your laptop. It'll tackle specific problem classes — molecular simulation, optimization, cryptography — where classical machines hit exponential walls.

How Qubits Actually Work

A qubit's state is written as:

|ψ⟩ = α|0⟩ + β|1⟩

Where α and β are probability amplitudes (complex numbers) and |α|² + |β|² = 1 always. The notation |0⟩ and |1⟩ is Dirac notation — the standard language of quantum mechanics.

The key insight: unlike classical probabilities, quantum amplitudes can be negative or complex. Two paths to a wrong answer can have amplitudes +0.5 and -0.5 that cancel to zero. Classical probabilities can never cancel. That's interference, and it's the entire reason quantum algorithms work.

When you measure a qubit, the superposition collapses. You get 0 (with probability |α|²) or 1 (with probability |β|²). The original state is destroyed — you can't go back and you can't peek at intermediate states.

Visually, any single qubit state maps to a point on the Bloch sphere — north pole is |0⟩, south pole is |1⟩, equator is equal superposition. Quantum gates are rotations on this sphere.

The Hardware Landscape

Building a qubit is the easy part. Keeping it stable long enough to compute — that's the engineering nightmare. Multiple competing approaches, and nobody's definitively won yet.

Superconducting Qubits

Tiny circuits cooled to ~15 millikelvins — colder than outer space. The current frontrunner in terms of investment and ecosystem.

Pros: Fast gate operations (~nanoseconds), leverages existing chip fabrication
Cons: Short coherence times (~100μs), massive dilution refrigerators, nearest-neighbor connectivity only
Who: IBM, Google, Rigetti

Trapped Ions

Individual atoms held by electromagnetic fields, manipulated with lasers. Each ion is a natural qubit.

Pros: Longest coherence times (seconds to minutes), highest gate fidelities, all-to-all connectivity
Cons: Slower gate operations (~microseconds), harder to scale qubit count
Who: IonQ, Quantinuum (Honeywell)

Photonic

Particles of light as qubits. Operations at room temperature.

Pros: No cooling needed, natural for quantum networking
Cons: Photon loss is a major challenge, deterministic single-photon generation is hard
Who: Xanadu, PsiQuantum

Neutral Atoms

The rising contender. Cold atoms held by optical tweezers in reconfigurable arrays.

Pros: Arrays of 1000+ atoms demonstrated, flexible geometry, long coherence
Cons: Gate fidelities still improving, less mature tooling
Who: QuEra, Pasqal

Topological (Microsoft's Bet)

Encodes information in exotic quasiparticles. Theoretically more error-resistant by design, but still largely unproven at scale.

The Major Players

IBM — Most accessible platform for learning. Free cloud access to real hardware. Qiskit is the most popular quantum SDK. Roadmap targets 100,000+ qubits by 2033 through modular architecture.

Google — Pushes the science frontier. Sycamore's "quantum supremacy" in 2019 was a landmark. Their Willow chip demonstrated that increasing qubits actually decreased error rates — arguably the most important quantum experiment in recent years.

IonQ — First pure-play quantum company to go public. Available on AWS, Azure, and Google Cloud. Coined "algorithmic qubits" to measure useful qubit count after accounting for errors.

Rigetti — Bets on hybrid classical-quantum computing. Owns their own chip fabrication facility. Their Ankaa processors focus on gate fidelity over raw qubit count.

Quantinuum — Consistently holds quantum volume records. Fewer qubits than IBM but far more reliable. If trapped ions win the hardware race, Quantinuum is probably the company to beat.

The quantum industry is in its "dial-up internet" phase. The race isn't about who has the most qubits — it's about who solves error correction first at scale.

The Build: First Quantum Circuit with Qiskit

Theory is good. Running code is better. Here's the simplest meaningful quantum circuit: Hadamard gate + measurement.

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

# 1. Build the circuit
qc = QuantumCircuit(1, 1)
qc.h(0)          # Hadamard gate — creates superposition
qc.measure(0, 0) # Measure — collapses to 0 or 1

# 2. Visualize
print("Circuit:")
print(qc.draw())
print()

# 3. Run on simulator (1000 shots)
sampler = StatevectorSampler()
job = sampler.run([qc], shots=1000)
result = job.result()

# 4. Results
counts = result[0].data.c.get_counts()
print(f"Results after 1000 shots: {counts}")

# 5. Show percentages
total = sum(counts.values())
for state, count in sorted(counts.items()):
    print(f"  |{state}⟩: {count} times ({100*count/total:.1f}%)")

Output:

Circuit:
     ┌───┐┌─┐
  q: ┤ H ├┤M├
     └───┘└╥┘
c: 1/══════╩═
           0

Results after 1000 shots: {'0': 512, '1': 488}
  |0⟩: 512 times (51.2%)
  |1⟩: 488 times (48.8%)

Roughly 50/50 — exactly what superposition predicts. The Hadamard gate transforms |0⟩ into (|0⟩ + |1⟩)/√2. When we measure, the superposition collapses and we get either 0 or 1 with equal probability. The numbers won't be perfectly 50/50 every time — that's the probabilistic nature of quantum mechanics.

Experiments That Build Intuition

Remove the H gate — qubit stays |0⟩, always measures 0. Confirms the default state.

X gate then H gate — still ~50/50, but the state is (|0⟩ - |1⟩)/√2 instead of (|0⟩ + |1⟩)/√2. That minus sign doesn't change measurement probabilities here, but matters for interference in larger circuits.

Double Hadamard — H applied twice cancels out. Always measures 0. H is its own inverse (H² = I).

Honest Assessment

What clicked: The distinction between superposition and classical probability. A qubit in superposition isn't "secretly 0 or 1 and we just don't know." It's genuinely in a combined state with amplitudes that can interfere.

What's still fuzzy: The Bloch sphere. I get the north-pole-south-pole mapping, but the relationship between angles and probability amplitudes needs more work.

What surprised me: How accessible Qiskit is. Going from zero to running a quantum circuit was fast. The barrier to entry for quantum programming is way lower than expected.

Tomorrow: Multi-qubit systems and entanglement. Building a Bell state — the simplest entangled state between two qubits.

Day 1 of quantum computing down. 99 more days of the polymath grind to go.

Follow the journey: @KarthNode | #KarthNode100Days