Physics · Advanced

Free wave packet spreading

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

A free quantum particle localized in space is a superposition of plane waves with different momenta. Because the dispersion relation is quadratic, components travel at different phase speeds, so the packet's width grows with time while its center moves at the group velocity. For a Gaussian the width grows as σ(t)=σ01+(ℏt2mσ02)2.

Intuition

Think of runners starting together at one line but with slightly different speeds. A narrow packet in position needs a broad spread of momenta (uncertainty principle). Each momentum component moves at its own velocity p/m, so the runners fan out. The momentum distribution never changes for a free particle, only the relative phases do, and those phases convert momentum spread into position spread. Lighter particles and tighter initial packets spread faster, because both give a larger velocity spread hbar/(2 m sigma0). At long times the width grows linearly, like a ballistic cloud. The packet also acquires a chirp: faster components end up at the front.

Key equations

iℏ∂tψ=−ℏ22m∂x2ψ
(1)

Free Schrödinger equation

ψ(x,t)=∫dk2πϕ(k)ei(kx−ω(k)t),ω=ℏk22m
(2)

Plane-wave superposition with quadratic dispersion

ψ(x,0)∝e−x2/(4σ02)eik0x
(3)

Gaussian initial packet with position standard deviation sigma0

σ(t)=σ01+(ℏt2mσ02)2
(4)

Width of probability density versus time

vg=dωdk|k0=ℏk0m
(5)

Packet center velocity

Derivation

  1. Fourier transform the initial Gaussian: phi(k) is proportional to exp(-sigma0^2 (k-k0)^2), so the momentum spread is sigma_k = 1/(2 sigma0).
  2. Each component evolves as e−iℏk2t/(2m) because the free Hamiltonian is diagonal in k.
  3. Write k=k0+q and expand: ω=ω0+vgq+ℏq2/(2m). The linear term shifts the center to x=vgt.
  4. The Gaussian integral over q has exponent −(σ02+iℏt2m)q2+i(x−vgt)q.
  5. Completing the square gives |ψ|2 proportional to exp⁡(−(x−vgt)22σ2) with σ2=σ02+(ℏt2mσ0)2.
  6. Factor σ02 to obtain the stated σ(t). For large t, σ≈ℏt/(2mσ0)=σvt with σv=ℏ/(2mσ0).

Worked example

Problem

An electron is prepared as a Gaussian packet with sigma0 = 0.10 nm. How wide is it after 1.0 fs? (hbar = 1.055e-34 J s, m = 9.11e-31 kg)

  1. Compute hbar t/(2 m sigma0^2): numerator = 1.055e-34 * 1.0e-15 = 1.055e-49.
  2. Denominator = 2 * 9.11e-31 * (1.0e-10)^2 = 1.822e-50.
  3. Ratio = 5.79.
  4. σ=σ01+5.792=0.10 nm×34.5=0.10×5.87 nm.

Answer About 0.59 nm, nearly six times the initial width after only one femtosecond.

Common mistakes

  • Thinking the packet spreads because of forces or interactions; it happens for a free particle through dispersion alone.
  • Claiming the momentum distribution broadens; |phi(k)|^2 is constant in time.
  • Confusing group velocity with phase velocity (ω/k=ℏk/2m is half the group velocity).
  • Forgetting that the width formula refers to the density |psi|^2 standard deviation, not the amplitude's parameter.
  • Assuming the minimum uncertainty product persists; it holds only at t = 0 (for this symmetric packet).

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(78 lines)
import sys
from manim import *
from blocks import *
import numpy as np

# Free Gaussian wave packet, hbar = m = 1, initial width sigma0 = 1.
SIGMA0 = 1.0


def integrate(y, x):
    """Trapezoid rule (avoids np.trapz, removed in new numpy)."""
    return float(np.sum((y[1:] + y[:-1]) * np.diff(x)) / 2)


def width(t, s0=SIGMA0):
    """Position std-dev of a free Gaussian packet: s0*sqrt(1+(t/(2 s0^2))^2)."""
    return s0 * np.sqrt(1 + (t / (2 * s0 ** 2)) ** 2)


def density(x, t, s0=SIGMA0):
    """|psi(x,t)|^2 for a Gaussian with std-dev width(t), normalised to 1."""
    s = width(t, s0)
    return np.exp(-x ** 2 / (2 * s ** 2)) / (s * np.sqrt(2 * np.pi))


TIMES = [0.0, 2.0, 4.0, 6.0]
COLORS = [C_MAIN, C_GOOD, C_ACCENT, C_BAD]


class Main(Scene):
    def construct(self):
        # Title
        TitleCard(self, "Wave packet spreading", "Free particle, Gaussian start")
        # Axes with first curve
        plot = CurvePlot(lambda x: density(x, 0.0), x_range=(-12, 12, 4),
                         y_range=(0, 0.45, 0.1), x_label="x", y_label="|psi|^2",
                         color=COLORS[0], x_length=8.5, y_length=4.0)
        plot.move_to(LEFT * 1.2 + DOWN * 0.1)
        self.play(Create(plot.axes), FadeIn(plot.labels))
        self.play(Create(plot.curve))
        # Legend of widths, computed
        legend = VGroup()
        t0 = Text(f"t=0  width={width(0):.2f}", font_size=24, color=COLORS[0])
        legend.add(t0)
        curves = [plot.curve]
        for k in range(1, len(TIMES)):
            t = TIMES[k]
            c = plot.axes.plot(lambda x, t=t: density(x, t), x_range=[-12, 12],
                               color=COLORS[k], use_smoothing=False)
            lab = Text(f"t={t:g}  width={width(t):.2f}", font_size=24, color=COLORS[k])
            legend.add(lab)
            curves.append(c)
        legend.arrange(DOWN, aligned_edge=LEFT, buff=0.2)
        legend.to_edge(RIGHT, buff=0.4).shift(UP * 0.5)
        self.play(FadeIn(legend[0]))
        for k in range(1, len(TIMES)):
            self.play(Create(curves[k]), FadeIn(legend[k]), run_time=1.5)
        eq = MathTex(r"\sigma(t)=\sigma_0\sqrt{1+\left(\frac{\hbar t}{2m\sigma_0^2}\right)^2}",
                     font_size=30)
        eq.next_to(legend, DOWN, buff=0.4)
        eq.set_x(legend.get_x())
        self.play(Write(eq))
        StepCaption(self, "The packet widens while its peak drops; area stays 1.")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert abs(width(0) - SIGMA0) < 1e-12
    xs = np.linspace(-60, 60, 20001)
    for t in TIMES:
        area = integrate(density(xs, t), xs)
        assert abs(area - 1) < 1e-6, area
        sd = np.sqrt(integrate(xs ** 2 * density(xs, t), xs))
        assert abs(sd - width(t)) < 1e-4
    ws = [width(t) for t in TIMES]
    assert all(a < b for a, b in zip(ws, ws[1:]))
    assert abs(width(100) - 50) < 0.02  # linear growth t/(2 s0)
    print("ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.