Quantum Speed Limits: A Lower Bound Is Not a Promise
A finite quantum speed limit does not guarantee arrival. An exact NumPy example shows why an equatorial qubit reaches an orthogonal state while a tilted one never does.
A qubit can have a perfectly good Hamiltonian, a nonzero energy uncertainty, and an infinite wait before it ever becomes orthogonal to its starting state. That is not a violation of a quantum speed limit. It is a reminder to read the inequality in the right direction.
A speed limit says how soon a change could possibly happen under stated assumptions. It does not promise that your particular evolution will make that change at all.
Start with a distance, not a stopwatch
Consider a closed system starting in a pure state and evolving under a time-independent Hamiltonian H. Define its survival probability and an angle between its initial and evolved states:
F(t) = |<psi(0)|psi(t)>|^2
L(t) = arccos(sqrt(F(t)))
DeltaE = sqrt(<H^2> - <H>^2)
Here the energy expectations are taken in the initial state. DeltaE stays constant under this time-independent evolution. The angle L is zero for the same physical pure state and pi/2 for orthogonal states. For pure qubits it is half the angular separation of their Bloch vectors, so keeping that factor of two straight matters.
The Mandelstam-Tamm bound is
L(t) <= t * DeltaE / hbar
The constant hbar is the reduced Planck constant. If an orthogonal state is reached at a time tau and DeltaE is nonzero, substituting L = pi/2 gives
tau >= pi * hbar / (2 * DeltaE)
The crucial word is if. This is a necessary lower bound on an orthogonalization time, not a guarantee that such a time exists.
The geometric explanation is particularly helpful: the separation between two states cannot exceed the length of the path actually traveled. For pure unitary evolution, the instantaneous path speed in this angle convention is the energy uncertainty divided by hbar. Deffner and Campbell's review connects the energy-time bound with this geometry and explains extensions beyond the simple setting used here.
One Hamiltonian, two very different journeys
Take a qubit Hamiltonian and a family of initial states:
H = (hbar * omega / 2) Z, with omega > 0
|psi_theta> = cos(theta/2)|0> + sin(theta/2)|1>
0 <= theta <= pi
The state rotates around the Bloch sphere's Z axis. Its latitude never changes. Direct calculation gives
DeltaE = (hbar * omega / 2) sin(theta)
F(t) = 1 - sin(theta)^2 * sin(omega*t/2)^2
For an equatorial state, theta = pi/2, the initial state is |+>. After a half-turn, t = pi/omega, it becomes |-> up to an irrelevant global phase. The states are orthogonal, and the lower bound is attained exactly.
Now tilt the initial state toward the north pole: theta = pi/3. Its energy uncertainty is still positive. The orthogonalization bound evaluates to 2*pi/(sqrt(3)*omega). But the exact formula shows that F(t) can never fall below 1/4. No amount of waiting under this fixed Hamiltonian produces an orthogonal state.
On the Bloch sphere, the reason is visible. The tilted state stays on a northern latitude circle, while the antipode of its starting point lies in the southern hemisphere. That destination is not on its orbit. A lower bound cannot make an unreachable destination reachable.
Test the bound in NumPy
The following code uses units with hbar = omega = 1. It builds the Hamiltonian, computes its variance in each input state, and evolves the state using the exact diagonal unitary. There is no time-step approximation and no hardware noise model.
import numpy as np
hbar = 1.0
omega = 1.0
Z = np.diag([1.0, -1.0])
H = 0.5 * hbar * omega * Z
def initial_state(theta):
return np.array([np.cos(theta/2), np.sin(theta/2)], dtype=complex)
def energy_spread(psi):
mean = np.vdot(psi, H @ psi).real
second = np.vdot(psi, H @ H @ psi).real
return np.sqrt(max(0.0, second - mean**2))
def evolve(psi, t):
phases = np.exp(-1j * np.diag(H) * t / hbar)
return phases * psi
t = np.pi / omega
for name, theta in [("equator", np.pi/2), ("tilted", np.pi/3), ("pole", 0.0)]:
psi = initial_state(theta)
delta = energy_spread(psi)
amplitude = np.clip(abs(np.vdot(psi, evolve(psi, t))), 0.0, 1.0)
fidelity = amplitude**2
angle = np.arccos(amplitude)
budget = t * delta / hbar
assert angle <= budget + 1e-12
tau_lower = f"{np.pi*hbar/(2*delta):.6f}" if delta > 1e-12 else "n/a (stationary)"
print(f"{name}: DeltaE={delta:.6f}, F(pi)={fidelity:.6f}")
print(f" angle={angle:.6f}, budget={budget:.6f}, tau_lower={tau_lower}")
Output:
equator: DeltaE=0.500000, F(pi)=0.000000
angle=1.570796, budget=1.570796, tau_lower=3.141593
tilted: DeltaE=0.433013, F(pi)=0.250000
angle=1.047198, budget=1.360350, tau_lower=3.627599
pole: DeltaE=0.000000, F(pi)=1.000000
angle=0.000000, budget=0.000000, tau_lower=n/a (stationary)
The budget is the path length accumulated by time t, not another estimate of the endpoint angle. At the half-turn, the equatorial trajectory follows a shortest path and saturates the bound. The tilted trajectory does not, so its endpoint angle is strictly smaller than the budget.
The pole example is an energy eigenstate. Its ket acquires a global phase, but its density matrix and all measurement probabilities stay unchanged. DeltaE is zero, so the code deliberately avoids dividing by zero. A nonzero energy eigenvalue is not the same thing as a nonzero energy uncertainty.
What the bound does not tell your compiler
Adding a constant times the identity to H changes the energy origin and the ket's global phase. It changes neither DeltaE nor the survival probability. A calculation that predicts a different Mandelstam-Tamm speed merely because you shifted the energy zero has gone wrong.
The assumptions matter just as much. If the Hamiltonian changes with time, replace the simple product t*DeltaE with the integral of the instantaneous energy uncertainty along the evolving state. Using only the final uncertainty would generally be incorrect. Mixed states and dissipative evolution require their own carefully specified distances and bounds; this pure-state calculation is not a universal recipe for them. The pure-state geometry and its generalizations make these distinctions explicit.
Finally, this is a bound on changing a specified input state under specified dynamics. It is not automatically a lower bound on the wall-clock duration of every gate implementation, an entire compiled circuit, or a noisy processor's execution time. Those questions also require constraints on controls and a definition of what counts as successful implementation.
The practical habit is simple: calculate the bound, then check the actual orbit. The bound can rule out an arrival that is too early. Only the dynamics can tell you whether the destination is ever reached.