Article
Quantum Physics · ⏱ ≈ 18 хв читання

Schrödinger Equation & Wave Packets

The time-dependent Schrödinger equation describes how quantum states evolve. Starting from the wave function and probability interpretation, we solve the particle-in-a-box analytically, apply WKB approximation to tunnelling through barriers, build Gaussian wave packets from superimposed plane waves, and simulate their propagation in JavaScript.

1. Wave Function & Probability Density

In quantum mechanics a particle is described by a complex-valued wave function Ψ(x, t). The physical content is the probability density:

ρ(x, t) = |Ψ(x, t)|² Normalisation: ∫₋∞^∞ |Ψ|² dx = 1 (particle is somewhere)

The wave function is not directly observable. Only |Ψ|² — the probability of finding the particle in an interval dx — has direct physical meaning. This Born rule, proposed by Max Born in 1926, was a radical departure from classical determinism.

Superposition: If Ψ₁ and Ψ₂ are valid states, so is any linear combination c₁Ψ₁ + c₂Ψ₂. This is the origin of quantum interference and entanglement.

2. Time-Dependent Schrödinger Equation

Schrödinger's 1926 equation governs how Ψ evolves in time:

iℏ ∂Ψ/∂t = ĤΨ = [−ℏ²/(2m) ∂²/∂x² + V(x)] Ψ where ℏ = h/(2π) ≈ 1.055 × 10⁻³⁴ J·s

When the potential V is time-independent, solutions separate:

Ψ(x, t) = ψ(x) e^(−iEt/ℏ) Time-independent Schrödinger equation (TISE): −ℏ²/(2m) d²ψ/dx² + V(x)ψ = Eψ

Solving the TISE is an eigenvalue problem: the allowed energies E are the eigenvalues of the Hamiltonian operator Ĥ, and ψ(x) are the corresponding eigenfunctions (stationary states).

3. Operators & Observables

Every physical observable corresponds to a Hermitian operator. Measurement yields one eigenvalue; immediately after, the state collapses to the corresponding eigenfunction:

Position x̂

Multiply by x. In x-basis: ⟨x⟩ = ∫ Ψ* x Ψ dx. Eigenvalues: all real numbers.

Momentum p̂

p̂ = −iℏ ∂/∂x. Eigenstates are plane waves: e^(ipx/ℏ). ⟨p⟩ = ∫ Ψ*(−iℏ∂Ψ/∂x) dx.

Energy Ĥ

Hamiltonian = kinetic + potential. Stationary states are energy eigenstates with definite E.

Commutators

[x̂, p̂] = iℏ — non-zero commutator means x and p cannot both be definite simultaneously (uncertainty principle).

4. Particle in a Box

The simplest exactly solvable system: infinite potential walls at x = 0 and x = L force ψ(0) = ψ(L) = 0. The solutions are standing waves:

ψₙ(x) = √(2/L) sin(nπx/L), n = 1, 2, 3, … Eₙ = n²π²ℏ²/(2mL²) = n² E₁ E₁ = π²ℏ²/(2mL²) (zero-point energy — quantum mechanics forbids E = 0)

Key features:

This model approximates conjugated π-systems in chemistry (e.g. β-carotene) and quantum well heterostructures in semiconductor lasers.

5. Quantum Tunnelling & WKB

A particle with energy E < V₀ can penetrate a finite potential barrier — a purely quantum effect with no classical analogue. For a rectangular barrier of width a:

Transmission probability (exact): T = [1 + (V₀² sinh²(κa))/(4E(V₀−E))]⁻¹ where κ = √(2m(V₀−E))/ℏ (imaginary wavenumber inside barrier)

The WKB (Wentzel–Kramers–Brillouin) approximation generalises this to slowly varying potentials:

T ≈ exp(−2 ∫ₓ₁^ₓ₂ κ(x) dx) κ(x) = √(2m[V(x)−E])/ℏ Integration runs over the classically forbidden region (V > E)

Tunnelling underlies: alpha decay (Gamow factor), scanning tunnelling microscopy (STM), tunnel diodes (Esaki, 1958 Nobel Prize), and flash memory storage cells.

6. Wave Packets & Uncertainty Principle

A Gaussian wave packet is a localised quantum state built from a superposition of plane waves:

Ψ(x, 0) = (2πσ²)^(−1/4) exp(−x²/(4σ²)) exp(ip₀x/ℏ) Momentum-space: φ(p) = (2πσ²/ℏ²)^(1/4) exp(−(p−p₀)²σ²/(2ℏ²)) Δx · Δp = ℏ/2 (minimum-uncertainty state)

As the packet propagates, dispersion causes it to spread:

σ(t) = σ√(1 + (ℏt/(2mσ²))²) The packet spreads because each momentum component travels at v = p/m

The Heisenberg uncertainty principle Δx·Δp ≥ ℏ/2 is not a statement about measurement disturbance — it is a fundamental property of all wave-like systems. A narrow position distribution requires broad momentum spread and vice versa.

7. JavaScript — Wave Packet Simulation

Gaussian wave packet propagation using a split-step Fourier method (alternating position and momentum space updates) on a discrete grid.

// Split-step Fourier method for 1D TDSE (free particle)
// Complex numbers stored as interleaved [re0, im0, re1, im1, ...]

function gaussianPacket(N, dx, x0, sigma, k0) {
  const psi = new Float64Array(N * 2);
  let norm = 0;
  for (let i = 0; i < N; i++) {
    const x = (i - N / 2) * dx;
    const env = Math.exp(-(x - x0) ** 2 / (4 * sigma ** 2));
    psi[2 * i]     = env * Math.cos(k0 * x);
    psi[2 * i + 1] = env * Math.sin(k0 * x);
    norm += env ** 2;
  }
  norm = Math.sqrt(norm * dx);
  for (let i = 0; i < N * 2; i++) psi[i] /= norm;
  return psi;
}

// Naive DFT for small grids (replace with FFT for production)
function dft(re, im, inverse) {
  const N = re.length;
  const sign = inverse ? 1 : -1;
  const oRe = new Float64Array(N), oIm = new Float64Array(N);
  for (let k = 0; k < N; k++) {
    for (let j = 0; j < N; j++) {
      const theta = sign * 2 * Math.PI * k * j / N;
      oRe[k] += re[j] * Math.cos(theta) - im[j] * Math.sin(theta);
      oIm[k] += re[j] * Math.sin(theta) + im[j] * Math.cos(theta);
    }
    if (inverse) { oRe[k] /= N; oIm[k] /= N; }
  }
  return [oRe, oIm];
}

function stepFreeParticle(psiRe, psiIm, dt, dx, mass) {
  const N = psiRe.length;
  const hbar = 1; // natural units
  // Forward DFT to momentum space
  let [kRe, kIm] = dft(psiRe, psiIm, false);
  // Multiply by exp(−i ℏ k² dt / (2m)) for each momentum mode
  for (let j = 0; j < N; j++) {
    const kj = (j < N / 2) ? j : j - N; // centred wavenumbers
    const kw = (hbar * kj ** 2 / (dx ** 2)) / (2 * mass);
    const phase = -kw * dt;
    const c = Math.cos(phase), s = Math.sin(phase);
    const r = kRe[j], im2 = kIm[j];
    kRe[j] = r * c - im2 * s;
    kIm[j] = r * s + im2 * c;
  }
  // Inverse DFT back to position space
  [psiRe, psiIm] = dft(kRe, kIm, true);
  return [psiRe, psiIm];
}

// Particle-in-box energy levels (atomic units: ℏ=m=1)
function boxEnergyLevels(L, n) {
  return Array.from({length: n}, (_, i) =>
    (Math.PI ** 2 * (i + 1) ** 2) / (2 * L ** 2)
  );
}
console.log('Box levels (L=10):', boxEnergyLevels(10, 5));

// WKB tunnelling coefficient for rectangular barrier
function wkbTunnelling(E, V0, a, m, hbar = 1) {
  if (E >= V0) return 1; // classical transmission
  const kappa = Math.sqrt(2 * m * (V0 - E)) / hbar;
  return Math.exp(-2 * kappa * a);
}
console.log('T (E=0.5, V=1, a=2):', wkbTunnelling(0.5, 1, 2, 1).toFixed(4));

8. Applications

Connection to simulation: The quantum simulation in this project's Wave Simulation uses numerical integration of the 2D wave equation — a classical analogue that shares the same mathematical structure as the Schrödinger equation.
🔬 Open Schrödinger Equation →