Quantum Fourier Transform (QFT) of a Single Qubit is Hadamard Transform

In an N-dimensional Hilbert space with basis states {|0⟩, |1⟩, …, |N−1⟩}, the Quantum Fourier Transform acts on a computational basis state |x⟩ as:

|x̃⟩ ≡ QFT |x⟩ ≡ ( 1 / √N ) ∑ [ e^(2π i x y / N) ] |y⟩    (from y = 0 to N − 1)

Just like the classical Discrete Fourier Transform (DFT), the QFT maps computational basis states into superpositions of states whose relative phases rotate at frequencies proportional to x. For an n-qubit system, the dimension of the state space is N = 2ⁿ.

Now, let us examine what happens when we set the number of qubits to n = 1, which gives N = 2¹ = 2. The summation runs over only two values: y = 0 and y = 1:

QFT |x⟩ = ( 1 / √2 ) ∑ [ e^(2π i x y / 2) ] |y⟩
        = ( 1 / √2 ) ∑ [ e^(i π x y) ] |y⟩
        = ( 1 / √2 ) [ e^(i π x · 0) |0⟩ + e^(i π x · 1) |1⟩ ]
        = ( 1 / √2 ) [ |0⟩ + e^(i π x) |1⟩ ]

Notice how the phase factor simplified: e^{2π i x y / 2} became e^{i π x y}. Because y ∈ {0, 1}, the first term is always e⁰ = 1, leaving only a phase factor of e^{i π x} on the |1⟩ component.

A single qubit has only two computational basis inputs: x = 0 and x = 1. Let us substitute each value into our formula:

Case 1: When x = 0

Substitute x = 0 into the phase term e^{i π · 0} = e⁰ = 1:

QFT |0⟩ = ( 1 / √2 ) [ |0⟩ + e^(i π · 0) |1⟩ ]
        = ( |0⟩ + |1⟩ ) / √2
        = |+⟩ ≡ H |0⟩

Case 2: When x = 1

Substitute x = 1 into the phase term using Euler’s identity, e^iπ = −1:

QFT |1⟩ = ( 1 / √2 ) [ |0⟩ + e^(i π · 1) |1⟩ ]
        = ( |0⟩ − |1⟩ ) / √2
        = |−⟩ ≡ H |1⟩

The Matrix Identity

Because the QFT transforms |0⟩ → |+⟩ and |1⟩ → |−⟩, its 2×2 unitary matrix is:

F_2 = ( 1 / √2 ) × [ [ 1,  1 ],
                         [ 1, -1 ] ] ≡ H

Thus, the single-qubit Quantum Fourier Transform and the single-qubit Hadamard gate are literally the exact same unitary operator!

In Qiskit 2.x, the Quantum Fourier Transform is available as QFTGate in qiskit.circuit.library. When we decompose a 1-qubit QFTGate, Qiskit compiles it directly into a single H gate:

Circuit 1: Decomposing a 1-qubit QFT in Qiskit 2.x produces an isolated Hadamard gate.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFTGate
from qiskit.quantum_info import Operator

# 1. Build circuit with 1-qubit QFT
qc = QuantumCircuit(1)
qc.append(QFTGate(1), [0])

# 2. Decompose the gate into elementary operations
qc_decomposed = qc.decompose()
print("Decomposed 1-Qubit QFT Circuit:")
print(qc_decomposed)

# 3. Extract the Unitary Matrix Operators
op_qft = Operator(qc).data
op_hadamard = Operator.from_label('H').data

print("
1-Qubit QFT Matrix:")
print(np.round(op_qft, 4))

print("
Standard Hadamard Matrix:")
print(np.round(op_hadamard, 4))

# 4. Verify mathematical equivalence
diff = np.linalg.norm(op_qft - op_hadamard)
print(f"
Frobenius Norm Difference: {diff:.2e}")
print(f"Equivalence Verified    : {np.allclose(op_qft, op_hadamard)}")

Execution Output:

Decomposed 1-Qubit QFT Circuit:
   ┌───┐
q: ┤ H ├
   └───┘

1-Qubit QFT Matrix:
[[ 0.7071+0.j  0.7071+0.j]
 [ 0.7071+0.j -0.7071+0.j]]

Standard Hadamard Matrix:
[[ 0.7071+0.j  0.7071+0.j]
 [ 0.7071+0.j -0.7071+0.j]]

Frobenius Norm Difference: 2.38e-16
Equivalence Verified    : True

Is the QFT of one qubit the exact same as the Hadamard gate?

Yes. Working through the N = 2 case of the QFT definition shows that QFT|0⟩ = |+⟩ and QFT|1⟩ = |−⟩, which are identical to the outputs of a Hadamard gate on the same inputs. For one qubit, QFT and H are literally the exact same unitary operator.

What is the Quantum Fourier Transform used for in quantum algorithms?

The QFT is the foundational engine of Quantum Phase Estimation (QPE) and Shor’s Factoring Algorithm. It converts periodic phase differences into measurable computational basis states, allowing a quantum computer to find periods exponentially faster than any classical algorithm.

How does the multi-qubit QFT generalize beyond 1 qubit?

When multiple qubits are involved (n > 1), the QFT cannot be achieved with independent Hadamard gates alone. It requires an interlocking ladder of Hadamards and controlled phase rotation gates (R_k), followed by SWAP gates to reverse qubit order. The 1-qubit case is the unique scenario where all controlled rotations vanish.