The Quantum Fourier Transform Explained

Here's something that quietly unsettles me: a single mathematical object, developed in the 1990s, sits underneath algorithms that solve completely unrelated problems. Factor enormous numbers? It's there. Estimate the energy levels of quantum systems? Also there. These problems share almost nothing in their surface logic — and yet something called the quantum Fourier transform is running under all of them, doing the same work, every time.

I cover unexplained phenomena for a living. I'm used to weird convergences. But usually the weirdness is in the claim, not in verified mathematics. The QFT is the kind of structural strangeness that doesn't require any leap of faith — it just requires sitting with it long enough to feel how odd it actually is.

Dr. Katie McCormick's recent episode of Qiskit in the Classroom is a genuinely good guide for that sitting. She walks through the QFT with the patience of someone who has watched people get lost here before and has thought carefully about where the rope should go.

From Fourier's Bold Claim to Quantum States

McCormick starts, correctly, with Joseph Fourier — specifically the 1822 claim that any function, no matter how complicated, can be expressed as a sum of sines and cosines. She demonstrates this with her son's toy piano, recording a middle C, running a Fourier transform on the audio data, and watching a single clean spike appear at about 260 Hz. Then she plays a C major chord, the waveform becomes a tangle, and the transform sorts it into three distinct peaks. It's a lovely demo — unpretentious, honest about what the math is actually doing.

The classical discrete Fourier transform works by multiplying a signal against candidate frequencies and summing the results. When a frequency is present in the signal, the contributions add constructively and you get a large output. When it isn't, the positive and negative contributions cancel. The periodic function doing this work is e^(iφ) — Euler's formula, which packages sine and cosine into a single complex exponential that spirals through the complex plane. McCormick's explanation here is clear: the complex packaging is algebraic tidiness, not mystery.

The quantum version, the QFT, looks almost identical at the formula level. The difference is that the input and output vectors are quantum state vectors, not classical data arrays. And here something shifts. As McCormick puts it, in the QFT, "the complex amplitudes are now an essential feature of the equation rather than a mathematical convenience." In the classical case, you can think of complex numbers as a convenient fiction — a way to keep cosine and sine traveling together. In the quantum case, those amplitudes are the physics. The phase of a quantum state isn't an artifact of notation. It's real, it's measurable in its effects, and the QFT is specifically a machine for manipulating it.

What the Gates Are Actually Doing

McCormick's gate-level walkthrough is where the video is most useful for anyone who wants to move from "I get the concept" to "I could build this."

The simplest QFT — on a single qubit, two basis states — is just a Hadamard gate. The Hadamard spreads a definite state (0 or 1) into an equal superposition, and for one qubit that superposition already has exactly the phases the QFT requires. Clean, almost too easy.

Scale up to two qubits and four basis states, and you need more precision. Equal superposition is still the goal, but now the phases across the basis states have to follow specific winding patterns — one Fourier basis state has a constant phase, another winds once around the complex plane as you step through the computational basis states, another winds twice, another three times. Hadamard gates generate the uniform superposition but can't set those phases individually. That's what controlled phase gates are for: they apply a phase to one qubit's |1⟩ component, but only when a second control qubit is in state |1⟩. The result is fine-grained phase control, conditioned on the state of the system. Swap gates tidy up the order at the end.

The larger QFT circuits — eight qubits, sixteen qubits — build iteratively from these same pieces. Each layer of the circuit adds another factor of two in dimension, nesting inside the previous structure. The gate count scales as O(n²) for n qubits, according to analysis on the Quantum Computing Stack Exchange — a resource worth bookmarking if you intend to go further with this.

I find myself wanting to sit with that scaling claim rather than just repeat it. O(n²) is genuinely efficient. What it doesn't tell you — and what McCormick's video wisely doesn't overstate — is whether that efficiency translates to practical advantage in any given application. The QFT is a subroutine, not an algorithm. Its speed matters only in the context of what's around it.

Phase Estimation: Where the Weirdness Pays Off

The application McCormick develops in the video is quantum phase estimation (QPE), and this is where I found myself genuinely disoriented in a productive way.

The setup: you have a unitary operator U and one of its eigenstates, ψ. Because U is unitary, its eigenvalue has magnitude exactly 1, so it can be written as e^(2πiθ) where θ is a real number between 0 and 1. QPE's goal is to learn θ.

The circuit applies U, U², U⁴, and so on to ψ, each controlled on a different qubit in a register of control qubits. Since ψ is an eigenstate, each application of U doesn't change the structure of ψ — it only adds a phase factor. The phase accumulates. And through a mechanism called phase kickback, the information about θ ends up not in the qubits you're acting on, but in the control qubits you're using to apply the unitaries.

After all the controlled operations, the control register is in a state that, McCormick notes, "has the form of a QFT." Apply the inverse QFT, and that phase information converts into amplitudes you can actually measure. What was invisible — encoded in quantum phase, which measurement alone can't access — becomes readable.

I keep turning this over. The QFT isn't computing something new. It's translating between two representations of information that already exists in the system: phase, which you can't see, and amplitude, which you can. It's a decoder ring for a language written in quantum mechanics' most inaccessible medium.

What I'm Actually Skeptical Of

Here's where I want to push back, or at least stay honest about what the video doesn't address.

McCormick's presentation is a model of clarity, but it's also — necessarily — a model of idealization. In the circuits she describes, every gate operates perfectly, every phase is what it's supposed to be, and the inverse QFT converts phase to amplitude without error. Real quantum hardware is noisier than that, and the gap between a clean circuit diagram and a reliable physical implementation is where most of quantum computing's present difficulty lives.

QPE is itself a subroutine in Shor's algorithm, which is the result that would break RSA encryption if run at cryptographic scale. One analysis from postquantum.com estimates that running Shor's algorithm at that scale would require on the order of 10,000 logical qubits. Current machines are nowhere near that in error-corrected logical terms.

I don't say this to dismiss the QFT or McCormick's explanation of it — the mathematics is sound and the conceptual architecture is real. But I think it matters to be clear about the distance between "this is how it works" and "this is something we can currently do." The QFT's elegance is not in question. Whether the hardware will ever catch up to the elegance is a genuinely open question, and one I notice McCormick doesn't have to answer because her video is about the mathematics, not the timeline.

That seems like the right scope for what the video is doing. It would be a different kind of dishonesty to lace a tutorial with hardware caveats every few minutes. But the reader coming to this material deserves to know which parts are settled and which parts are still waiting on engineering.

Why This Mathematical Object Is Worth Your Attention

The QFT is, as McCormick says, "more than a mathematical curiosity. It's the mechanism that lets quantum computers turn hidden patterns in the quantum phase into useful information." That's a careful formulation, and I think it's accurate. The QFT doesn't create the patterns. It makes them legible.

What strikes me — and what I'll keep sitting with — is the question of how much else might be hiding in phase that we don't yet know how to read. The QFT is one decoder. It works because the specific structure of its target (phase encoding, unitary eigenvalues) maps cleanly onto the specific structure of the transform. That correspondence isn't obvious in advance. It was found.

Which suggests other correspondences might be waiting somewhere. Other patterns encoded in quantum states in ways that current algorithms don't yet know how to surface. That's not a claim — it's a question. And questions like that are, professionally speaking, my entire thing.

---

Nadia Marchetti is BuzzRAG's Unexplained Phenomena Correspondent.