Tag: quantum

Quantum Computing: A Complete Learning Path

QUANTUM SERIES 2026
The complete learning path, from a single qubit to Grover’s algorithm.

This is the index to the Techucation Quantum Series: a sequence of hands-on posts that build quantum computing from the ground up. Each one stands on its own, but together they form a single arc, from what a qubit actually is, through the rules that make quantum mechanics strange, to the algorithms that turn those rules into a real speedup. The order below is a learning path from first principles to algorithms, not the order the posts were written.

New to the topic? Read top to bottom. Already comfortable with qubits and gates? Skip ahead to the algorithms in Section 4.
Foundational Pre-reading: The Math Behind the Phase
0
Euler’s Formula: Why eiφ Is Just Shorthand for a Circle
Optional warm-up before the qubit posts: the complex plane, i as a 90° rotation, and why the phase factor eiφ traces a circle.
1  ·  Start Here: Qubits and Superposition
1
Introduction to Quantum Computing: Qubits, Hadamard Gates, and Superposition
First principles: what a qubit is, how the Hadamard gate builds superposition, and why tensor products scale the state space.
2  ·  The Hadamard Toolkit
2
The Quantum Fourier Transform of a Single Qubit is the Hadamard Transform
The one-qubit QFT turns out to be exactly the Hadamard gate, a small result that anchors the bigger picture.
3
The Walsh-Hadamard Matrix: Backbone of Grover’s Diffusion Operator
How the Hadamard sign table generalises to n qubits and powers Grover’s diffusion step.
3  ·  The Rules of the Quantum World
4
Reversible Computation in Quantum Computing
Why every quantum gate must be reversible, and how ancilla bits turn irreversible logic into unitary logic.
5
The Cost of Garbage in Quantum Computing
Leftover junk qubits destroy interference; uncomputation cleans them up to protect the speedup.
6
The No-Cloning Theorem: Why You Cannot Copy a Qubit
A short proof that an unknown quantum state cannot be duplicated, and what that impossibility makes possible.
7
Quantum Teleportation, and Why It Is Not Cloning
Moving an unknown qubit from one place to another without ever copying it, using entanglement and two classical bits.
4  ·  Algorithms
8
Understanding Phase Kickback
The mechanism where the target qubit flips the control’s phase, the trick underneath Deutsch’s, Grover’s, and Shor’s.
9
Deutsch’s Algorithm: The Four Cases
The four one-bit Boolean functions, the reversible oracle, and the single query that beats the classical two.
10
Deutsch Revisited: Quantum vs Classical in Qiskit
The same algorithm in running Qiskit code: two classical queries against one quantum query.
11
Grover’s Algorithm: Inversion About the Mean
A full three-qubit walkthrough of the oracle and the amplitude amplification that surfaces the marked item.
5  ·  Entanglement and Bell’s Inequality
12
The CHSH Game Simulator and Bell’s Inequality
An interactive game where quantum entanglement beats the classical 75 percent ceiling and violates Bell’s inequality.

Quantum Series 2026  ·  Built with Qiskit 1.x

✦ This article was generated with the assistance of Claude by Anthropic ✦

Quantum Teleportation in Quantum Computing, and Why It Isn’t Cloning

QUANTUM SERIES 2026
Moving a qubit you are forbidden to copy.

Teleportation is the most over-sold word in quantum computing. It conjures Star Trek transporters and faster-than-light messaging, and almost every popular account quietly implies you end up with a copy of the original. You do not. Quantum teleportation moves an unknown quantum state from one qubit to another while destroying the original, and that destruction is not an incidental detail. It is the mechanism that keeps the protocol on the right side of the no-cloning theorem.

1  ·  A quick word on no-cloning

This whole protocol is haunted by the no-cloning theorem: there is no operation that copies an arbitrary unknown quantum state. That proof and its consequences are covered in a recent post, The No-Cloning Theorem in Quantum Computing: Why You Can’t Copy a Qubit, and are not re-derived here.

The single fact needed going forward: you cannot deterministically duplicate an unknown qubit. The qualifiers matter, because teleportation lives in the gaps between them. The theorem forbids copying unknown states (a known state you can re-prepare at will), it forbids deterministic, perfect copies, and it is a statement about unitary operations — and measurement, which teleportation leans on at the decisive moment, is not unitary.

2  ·  Why teleportation is not cloning

Here is the distinction in one sentence: cloning would leave |ψ⟩ in two places; teleportation leaves it in exactly one.

Partway through the protocol, Alice’s message qubit is measured. Measurement collapses it into a classical basis state — a plain |0⟩ or |1⟩ carrying none of the original amplitudes. By the time Bob’s qubit holds |ψ⟩, Alice’s qubit demonstrably does not. The state was relocated, and the accounting is exact: one copy in, one copy out. No moment ever exists where two qubits both carry |ψ⟩, so there is nothing for the no-cloning theorem to object to.

This also kills the faster-than-light fantasy. The protocol forces Alice to send Bob two ordinary classical bits. Until they arrive, Bob’s qubit is information-free, as the algebra below shows.

3  ·  The complete circuit

Here is the whole protocol in a single circuit. Read it left to right; the amber dashed dividers mark the three stages. The message qubit q0 starts in the unknown state |ψ⟩, while q1 and q2 both start in |0⟩.

1. Bell pair2. Alice measures3. Bob corrects
q0:HM
q1:H+M
q2:+XZ

Stage 1 — Bell pair. Alice and Bob share an entangled pair: an H on q1 followed by a CNOT from q1 onto q2 prepares (|00⟩ + |11⟩)/√2 across the two halves.

Stage 2 — Alice measures. Alice folds her message into the pair (a CNOT from q0 onto q1, then an H on q0) and measures both of her qubits, collapsing them to two classical bits.

Stage 3 — Bob corrects. Depending on those two bits, Bob applies an X and/or a Z to q2 — the X controlled by Alice’s q1 bit, the Z by her q0 bit — and q2 emerges as |ψ⟩. The next section is the algebra that fixes exactly which correction each outcome needs.

4  ·  The protocol in bra-ket and tensor form

Now the algebra behind that circuit. Three qubits: q0 carries |ψ⟩ = α|0⟩ + β|1⟩ (Alice), q1 is Alice’s half of the Bell pair, and q2 is Bob’s half. They pre-share |Φ+⟩ = (|00⟩ + |11⟩)/√2 on q1 q2.

Step 1 — the starting state. Tensor the message against the Bell pair:

|ψ⟩ = α|0⟩ + β|1⟩            (the unknown message on q0)

|ψ⟩ ⊗ |Φ+⟩ = (α|0⟩ + β|1⟩) ⊗ (|00⟩ + |11⟩)/√2
           = (1/√2) [ α|000⟩ + α|011⟩ + β|100⟩ + β|111⟩ ]

Step 2 — Alice’s CNOT (control q0, target q1):

CNOT (control q0, target q1)  flips q1 wherever q0 = 1:

= (1/√2) [ α|000⟩ + α|011⟩ + β|110⟩ + β|101⟩ ]

Step 3 — Alice’s Hadamard on q0. Substitute |0⟩ → (|0⟩+|1⟩)/√2 and |1⟩ → (|0⟩−|1⟩)/√2, then collect by the value of (q0 q1):

H on q0, then collect by the pair Alice will measure (q0 q1):

= (1/2) [ |00⟩ (α|0⟩ + β|1⟩)    ← case A
        + |01⟩ (α|1⟩ + β|0⟩)    ← case B
        + |10⟩ (α|0⟩ − β|1⟩)    ← case C
        + |11⟩ (α|1⟩ − β|0⟩) ]  ← case D

Each bracketed q2 state is the original |ψ⟩ acted on by a known Pauli. Alice measures, gets one of four outcomes (each with probability 1/4), sends the two bits to Bob, and Bob undoes the Pauli. The Case column ties each row back to the matching line in Step 3:

Case
Alice measures (q0 q1)
Bob holds on q2
Relation to |ψ⟩
Bob applies
A
00
α|0⟩ + β|1⟩
I |ψ⟩
nothing
B
01
α|1⟩ + β|0⟩
X |ψ⟩
X
C
10
α|0⟩ − β|1⟩
Z |ψ⟩
Z
D
11
α|1⟩ − β|0⟩
ZX |ψ⟩
X then Z

Bob applies Zm0 Xm1 — an X if m1 = 1, then a Z if m0 = 1 — and every branch lands back on α|0⟩ + β|1⟩ = |ψ⟩.

5  ·  Qiskit — classical feed-forward

This version measures mid-circuit and uses real classical conditioning via if_test, the honest picture of the protocol. The verification trick: rather than read out Bob’s state, apply the inverse of the preparation to q2. If teleportation worked, that must collapse q2 to |0⟩ on every shot.

import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.circuit.library import StatePreparation
from qiskit.quantum_info import random_statevector
from qiskit_aer import AerSimulator

# Unknown state to teleport (StatePreparation is unitary -> invertible)
psi  = random_statevector(2)
prep = StatePreparation(psi)

q   = QuantumRegister(3, “q”)     # q0 message, q1 Alice, q2 Bob
mz  = ClassicalRegister(1, “mz”)  # q0 result -> drives Z
mx  = ClassicalRegister(1, “mx”)  # q1 result -> drives X
out = ClassicalRegister(1, “out”) # verification bit
qc  = QuantumCircuit(q, mz, mx, out)

qc.append(prep, [0]); qc.barrier()        # 1. load |ψ⟩ onto q0
qc.h(1); qc.cx(1, 2); qc.barrier()        # 2. Bell pair on (q1,q2)
qc.cx(0, 1); qc.h(0)                      # 3. Alice’s basis change
qc.measure(0, mz); qc.measure(1, mx); qc.barrier()

with qc.if_test((mx, 1)):                 # 4. Bob’s corrections
    qc.x(2)
with qc.if_test((mz, 1)):
    qc.z(2)
qc.barrier()

qc.append(prep.inverse(), [2])            # 5. un-prepare on Bob: must read 0
qc.measure(2, out)

counts = AerSimulator().run(transpile(qc, AerSimulator()), shots=4000).result().get_counts()
clean  = all(k.split()[0] == “0” for k in counts)   # leftmost bit = out
print(counts); print(“Teleportation verified:”, clean)
The out bit comes back 0 on 100% of shots regardless of the random (mx, mz) branch — exactly the claim that Bob reconstructs |ψ⟩ in every case.

6  ·  No faster-than-light, and the takeaway

Before Bob learns (m0, m1), his qubit is an equal mixture of the four branch states. Averaging the four projectors gives the Pauli twirl:

ρ_Bob = (1/4)( |ψ⟩⟨ψ| + X|ψ⟩⟨ψ|X
              + Z|ψ⟩⟨ψ|Z + XZ|ψ⟩⟨ψ|ZX )  =  I/2   for every |ψ⟩

for any |ψ⟩. Bob’s local state is identical no matter what Alice sent, so no information has reached him yet. The classical bits are not a formality — they are the only thing that carries the state across, and they travel no faster than light.

Takeaway. No-cloning forbids duplicating an unknown qubit (proof here). Teleportation never attempts a copy: it entangles the message with a shared Bell pair, measures the original out of existence, and ships two classical bits naming which of four Pauli corrections rebuilds the state on the other end. Exactly one copy before, exactly one after. No-cloning is not a bug the protocol works around — it is the reason the protocol has to look the way it does.

Quantum Series 2026  ·  Built with Qiskit 1.x

✦ This article was generated with the assistance of Claude by Anthropic ✦

Euler’s Formula: Why e^(iφ) Is Just Shorthand for a Circle

QUANTUM SERIES 2026
Foundational pre-reading: why eiφ is just shorthand for a circle.

This is the foundational pre-reading for the upcoming Quantum Mechanics series. Before wave functions, probability amplitudes, and the quirks of qubits, one piece of mathematics has to be demystified: Euler’s formula. Quantum physics literature leans on the expression eiφ, the phase factor, on almost every page. Raising a constant to an imaginary exponent looks intimidating at first, but conceptually it is nothing more than elegant shorthand for drawing a circle.

New to the math? Read top to bottom. Comfortable with the complex plane already? Skip ahead to Section 4 to see why quantum mechanics relies on this shorthand.

1  ·  The geometry: mapping the complex plane

On a standard 2D graph, points are plotted against an x-axis and a y-axis. The complex plane keeps the layout but changes the meaning: the horizontal axis measures real numbers, and the vertical axis measures imaginary numbers, the multiples of i. Draw a unit circle, a circle of radius 1, and any point on it is fixed by a single angle φ measured counter-clockwise from the positive real axis. Basic trigonometry gives its two coordinates: the horizontal coordinate is cos φ and the vertical coordinate is sin φ. Placed in the complex plane, that point is the real part plus i times the imaginary part, which is exactly Euler’s formula:

eiφ = cos φ + i sin φ
Re
Im
eiφ
φ
cos φ
sin φ
1
Fig 1: a point eiφ on the unit circle. Its horizontal coordinate is cos φ, its vertical coordinate is sin φ.

As φ increases from 0 to 2π, the point sweeps out a full circle around the origin. The right-hand side spells out the coordinates; the left-hand side, the exponential, is the shorthand for the same thing.

2  ·  The mechanics of i: the ultimate rotator

Why should a circle be written as an exponent? The answer starts by reframing the imaginary unit. Algebraically i is the square root of minus one. Geometrically, multiplying any number by i rotates it 90 degrees counter-clockwise in the complex plane. Start at 1, pointing right. One multiplication by i gives i, pointing straight up. Another gives −1, pointing left. Two more pass through −i and return to 1.

1  ×i →  i  ×i →  −1  ×i →  −i  ×i →  1
each ×i is a 90° counter-clockwise turn

Seen this way, i is not really a number at all. It is a rotational operator.

3  ·  The calculus: why the base e?

The base e earns its place through calculus: ex is the only function that is its own derivative, so its rate of change always equals its current value. Feeding the rotational operator i into the exponent and differentiating by the chain rule gives:

ddφ eiφ = i eiφ

That small equation carries a large physical statement. The velocity of the point, the direction it is moving, equals its current position multiplied by i, which means the velocity is always exactly 90 degrees away from the position vector.

90°
eiφ
i·eiφ
Fig 2: the velocity i·eiφ is the position vector turned 90°, so it stays tangent to the circle. Perpetual perpendicular velocity is exactly circular motion.

In geometry and orbital mechanics alike, a velocity that stays perpendicular to the position vector is the signature of perfect circular motion. The exponential therefore encodes the act of tracing a circle, automatically.

4  ·  Why quantum mechanics needs this

Rather than writing out a vector built from a real cosine component and an imaginary sine component every time, physicists write the phase factor and move on. The shorthand packs the coordinates, the radius, and the continuous rotation into one compact exponent. The next articles in this series turn to quantum superposition, where relative phase decides whether amplitudes interfere constructively or destructively. Because that relative phase behaves exactly like an angle travelling around a circle, eiφ is the natural tool for modelling it.

Quantum Series 2026  ·  Foundational pre-reading

✦ Drafted with Gemini by Google, formatted and illustrated with Claude by Anthropic ✦

Space.com: The double-slit experiment: Is light a wave or a particle?

https://www.space.com/double-slit-experiment-light-wave-or-particle