Physics Voyage https://physicsvoyage-github-io.pages.dev/feed.html quarto-1.4.554 Sun, 14 Jun 2026 00:00:00 GMT Quantum Tunneling in a Quartic Double-Well Potential Aditya Kumar https://physicsvoyage-github-io.pages.dev/Blog/Random_Physics/quartic_double_well.html

Why This Problem Matters

The quartic double-well potential is far more than a textbook exercise. It is the simplest system that captures the physics of quantum tunneling — a phenomenon with no classical analogue — and its consequences show up across nearly every branch of modern physics.

Here is why physicists keep coming back to this problem:

  • Molecular physics: The ammonia molecule () has two equivalent configurations (nitrogen above or below the hydrogen plane). The nitrogen atom tunnels between these two positions through a double-well potential. The resulting energy splitting is the operating principle behind the ammonia maser, one of the first masers ever built.
  • Condensed matter: Proton transfer in hydrogen bonds, defect migration in crystals, and the dynamics of Josephson junctions in superconducting circuits are all governed by double-well tunneling.
  • Quantum computing: Superconducting qubits (transmon, flux qubit) are engineered double-well systems. The tunnel splitting is the qubit frequency. Controlling it is the entire game.
  • Quantum field theory: The double-well potential is the prototype for spontaneous symmetry breaking and instanton physics. The tunneling amplitude between degenerate vacua is computed using the same overlap integral we will derive below.
  • Chemical physics: Reaction rates in chemistry often involve tunneling through an activation barrier. The Arrhenius law breaks down at low temperatures precisely because of quantum tunneling effects captured by models like this one.

In short, solving the quartic double well teaches you the machinery — overlap integrals, tight-binding models, finite-difference discretization — that you will reuse in far more complex problems.

The Problem

Problem Statement

Consider a particle of mass confined in the one-dimensional quartic double-well potential:

Tasks:

  1. Analyze the potential landscape: locate the minima, compute the barrier height, and determine the effective harmonic frequency near each minimum.
  2. Construct approximate localized states using the harmonic approximation.
  3. Using the two-state tight-binding model, compute the overlap (tunneling) integral and derive the analytical energy splitting.
  4. Solve the full eigenvalue problem numerically using the Finite Difference Method (FDM).
  5. Visualize the eigenstates, verify their properties, and simulate the time-dependent tunneling dynamics.
Tip

Parameters used throughout this article: , , , . These are natural units chosen so that all quantities are of order unity, making the numerics clean and the plots easy to read.

Analytical Solution

We now solve the problem step by step, starting from the shape of the potential and building up to the analytical prediction of the tunnel splitting.

Step 1 — Locating the Minima

To find the extrema of , we set the first derivative to zero:

This gives three solutions:

  • — a local maximum (the top of the barrier)
  • — two symmetric minima (the bottoms of the wells)

For our parameters:

Step 2 — Barrier Height

The potential at the minima is:

The potential at the barrier top is . Therefore the barrier height above the well floor is:

This is the energy a classical particle would need to climb over the hill. A quantum particle, as we shall see, needs far less.

Step 3 — Harmonic Approximation Near Each Minimum

We Taylor-expand around to second order. Writing (where is a small displacement):

Computing the second derivative:

This is the curvature of a harmonic oscillator with spring constant . The effective frequency is:

Each well, in isolation, behaves like a simple harmonic oscillator with this frequency.

Step 4 — Constructing Localized States

If the barrier were infinitely high, the two wells would be completely isolated. Each would support its own ground-state wavefunction — a Gaussian centred at the respective minimum.

We define:

  • — the ground state of the left well (centred at )
  • — the ground state of the right well (centred at )

Within the harmonic approximation, these are:

Both states have the same energy:

At this stage, the system appears to have a doubly degenerate ground state. But this degeneracy is an artefact of ignoring the barrier region. The next step lifts it.

Step 5 — The Overlap Integral (Tunneling Coupling)

Because the barrier has finite height, the tail of leaks into the right well and vice versa. The two states are not truly orthogonal — they overlap inside the barrier.

We quantify this overlap through the tunneling matrix element:

What this integral captures:

  • The integrand is significant only in the classically forbidden region (under the barrier), where both and have small but nonzero amplitude.
  • The operator includes the kinetic energy term, which measures how rapidly the wavefunction changes — and it changes most rapidly precisely in the barrier region.
  • A higher barrier or a wider barrier suppresses the overlap exponentially, making smaller.
  • A lower or thinner barrier increases the overlap, making larger.

The magnitude of directly controls how fast the particle tunnels.

Step 6 — Solving the 2 x 2 Eigenvalue Problem

In the basis , the full Hamiltonian takes the form of a matrix:

To find the true energy eigenstates, we solve the secular equation:

This yields two distinct energy levels:

Step 7 — The Eigenstates: Bonding and Antibonding

Substituting each eigenvalue back into , we find the corresponding eigenstates:

  • Ground state (symmetric / bonding): This state has even parity, no nodes, and its wavefunction has identical positive humps in both wells.

  • First excited state (antisymmetric / antibonding): This state has odd parity, exactly one node at , and its wavefunction has opposite signs in the two wells.

Step 8 — The Tunnel Splitting

The energy gap between the two states is:

Key observations:

  • The splitting is exponentially small when the barrier is tall and wide, because depends on the overlap of Gaussian tails under the barrier.
  • The splitting is a direct, measurable signature of tunneling. If , there is no tunneling. Period.
  • The tunneling time — the time for a particle to traverse from one well to the other — is:

The two-state tight-binding model: isolated well states combine into symmetric (bonding) and antisymmetric (antibonding) eigenstates.

Computational Workflow

The analytical two-state model gives us the correct qualitative picture, but it rests on the harmonic approximation — which ignores anharmonic corrections entirely. To get precise eigenvalues and eigenstates, we turn to numerics.

The Finite Difference Method (FDM)

The idea is straightforward:

  • Discretize space into grid points: .
  • Replace the second derivative with a three-point central difference:
  • Assemble the Hamiltonian as an sparse matrix: , where is tridiagonal (kinetic energy) and is diagonal (potential energy).
  • Diagonalize to extract eigenvalues and eigenvectors.

The matrix equation we solve is:

This is an ordinary matrix eigenvalue problem — every linear algebra library can handle it.

Python Implementation

import numpy as np
from scipy.sparse import diags
from scipy.sparse.linalg import eigsh

# --- Physical Parameters ---
hbar, m = 1.0, 1.0
alpha, beta = 4.0, 0.5

# --- Spatial Grid ---
N = 1000
x = np.linspace(-4, 4, N)
dx = x[1] - x[0]

# --- Potential Energy ---
V = -0.5 * alpha * x**2 + beta * x**4

# --- Kinetic Energy (tridiagonal matrix) ---
coeff = hbar**2 / (2 * m * dx**2)
main_diag = 2 * coeff * np.ones(N) + V
off_diag  = -coeff * np.ones(N - 1)

H = diags([off_diag, main_diag, off_diag], [-1, 0, 1])

# --- Solve for 6 lowest eigenvalues ---
eigenvalues, eigenvectors = eigsh(H, k=6, which='SM')

# --- Results ---
dE = eigenvalues[1] - eigenvalues[0]
tau = np.pi * hbar / dE

print(f"E_0        = {eigenvalues[0]:.4f}")
print(f"E_1        = {eigenvalues[1]:.4f}")
print(f"Splitting  = {dE:.4f}")
print(f"Tunnel time = {tau:.1f}")
Important

Why sparse matrices? The Hamiltonian is an matrix, but only three diagonals are nonzero. Storing and operating on the full dense matrix would cost memory and time for diagonalization. Using scipy.sparse, we reduce this to memory and obtain the lowest few eigenvalues in time per Lanczos iteration.

Results and Visualization

The Potential Landscape

The figure below shows the quartic potential with our chosen parameters. The two minima sit at , with a depth of and a barrier height of above the well floors.

Anatomy of the quartic double-well potential, with annotated minima, barrier height, and effective harmonic curvature.

Eigenvalues and Energy Splitting

The six lowest eigenvalues computed by the FDM are:

Parity Doublet Splitting
0 Even 1st
1 Odd 1st
2 Even 2nd
3 Odd 2nd
4 Even 3rd
5 Odd 3rd

Key observations from the table:

  • The lowest doublet has a tiny splitting of — the states are nearly degenerate, because the barrier is tall relative to their energy.
  • Higher doublets have progressively larger splittings, because those states sit closer to the top of the barrier and “see” a thinner effective wall.
  • Every doublet consists of one even-parity and one odd-parity state, as required by the symmetry of the potential.

The computed tunneling time is:

Energy level diagram showing the doublet structure and the tunnel splitting.

Eigenstates and Node Structure

The wavefunctions reveal the bonding/antibonding structure predicted by the analytical model:

  • (ground state): Symmetric, no nodes, equal positive amplitude in both wells.
  • (first excited state): Antisymmetric, one node at , opposite signs in the two wells.
  • , : The second doublet, with 2 and 3 nodes respectively.

The node count matches the Sturm oscillation theorem: the -th eigenstate has exactly nodes.

First four eigenstates of the quartic double well, vertically offset by their eigenvalues.

Node analysis of the first four eigenstates. Positive and negative lobes are shaded differently.

Verification: Orthonormality and Probability Distribution

Two sanity checks confirm the numerical solution is correct:

  • Orthonormality: The overlap matrix is the identity matrix to machine precision ( off-diagonal).
  • Delocalization: Every eigenstate has exactly 50% probability in the left well and 50% in the right well, as demanded by parity symmetry.

Left: Overlap matrix confirming orthonormality. Right: Integrands showing the cancellation mechanism.

Probability distribution across the two wells for each eigenstate.

Harmonic Approximation vs. Exact Solution

The harmonic approximation captures the Gaussian envelope near each minimum but fails in the barrier region:

  • It overestimates the ground-state energy ( vs. the true ), because it ignores the anharmonic “flattening” of the quartic potential.
  • It underestimates the wavefunction amplitude under the barrier, because the Gaussian tails drop off faster than the true eigenstates.

Comparison of harmonic-approximation states (dashed) with exact FDM eigenstates (solid).

Tunneling Dynamics

This is where the physics becomes vivid.

Suppose we prepare the particle entirely in the right well at . This localized state is not an energy eigenstate — it is a superposition:

Under time evolution, the two components pick up different phase factors (because ), and the wavefunction becomes:

The probability density oscillates in time:

What happens at each stage:

  • : The particle is 100% in the right well.
  • : The cosine term vanishes. The probability is 50-50 across both wells.
  • : The cosine term flips sign. The particle is now 100% in the left well.
  • : The particle returns to the right well. The cycle repeats.

The well-occupation probabilities follow perfect sinusoidal curves:

Probability density at four characteristic times during the tunneling process.

Probability of occupying the right (blue) and left (red) well as a function of time.

Physics Interpretation

Having worked through the mathematics and the numerics, let us step back and ask: what does this all mean physically?

Tunneling is not teleportation

  • The particle does not instantaneously jump from one well to the other. It leaks through the barrier continuously, like water seeping through a porous wall.
  • The tunneling time (in natural units) is finite and measurable. It is governed entirely by the energy splitting .
  • If we increase the barrier height or width, shrinks exponentially, and the tunneling time grows exponentially. In the limit of an infinite barrier, — tunneling ceases, and the particle is permanently trapped.

Why the ground state is symmetric

  • The symmetric (bonding) state has no node. It does not vanish anywhere between the two wells. This means its second derivative is smaller, which translates to a lower kinetic energy.
  • The antisymmetric (antibonding) state has one node at . The wavefunction must pass through zero and reverse sign, requiring a steeper slope in the barrier region and therefore a higher kinetic energy.
  • The symmetric state always wins. This is the same reason the bonding molecular orbital in lies below the antibonding one.

The doublet structure encodes the barrier shape

  • States deep below the barrier top form tight doublets (small ), because they barely penetrate the barrier.
  • States near or above the barrier top form wide doublets (large ), because they extend freely across both wells.
  • The progression of splittings — , , — is a spectroscopic fingerprint of the barrier geometry.

Eigenstates are delocalized; particles are not

  • Every energy eigenstate lives equally in both wells (). A particle in an eigenstate has no preference for left or right.
  • A particle localized in one well is necessarily in a superposition of eigenstates. It is this superposition that evolves in time and produces the tunneling oscillation.
  • Localization is not a property of the Hamiltonian; it is a property of the initial condition.

Summary

What we accomplished in this article
Step What we did Key result
1 Located the minima of the quartic potential ,
2 Approximated each well as a harmonic oscillator
3 Constructed localized states and Gaussian wavefunctions centred at each minimum
4 Computed the overlap (tunneling) integral Coupling quantifies barrier penetration
5 Solved the eigenvalue problem , splitting
6 Solved numerically via FDM ( grid) , ,
7 Verified eigenstates (nodes, orthonormality, parity) All checks passed to machine precision
8 Simulated tunneling dynamics ; sinusoidal probability oscillation

The quartic double well, despite its simplicity, contains the essential ingredients of tunneling physics: a degenerate landscape, an overlap integral that lifts the degeneracy, and a time-dependent oscillation whose frequency is set by the splitting. Understanding this system thoroughly equips you to tackle ammonia inversion, proton transfer, Josephson junction dynamics, and instanton calculations in quantum field theory — all of which are, at their core, double-well problems.

]]> Quantum Physics Computational Physics Python Advanced https://physicsvoyage-github-io.pages.dev/Blog/Random_Physics/quartic_double_well.html Sun, 14 Jun 2026 00:00:00 GMT Quantum Dynamics: Analytical & Computational Solutions in Python Aditya Kumar https://physicsvoyage-github-io.pages.dev/Blog/Random_Physics/Quantum Dynamics.html

You Will Learn

S.No. Analytical Methods Computational Methods
1 Operator Algebra (, ) Libraries: Python, NumPy, SciPy, Matplotlib
2 Hermite Polynomials & Special Functions Matrix Diagonalization
3 WKB Approximation Finite Difference Method (FDM)
4 Eigenfunction Expansion Shooting Method
5 Gaussian Integrals & Error Functions Runge-Kutta Methods (RK4)
6 Dirac Notation Manipulation Crank-Nicolson Scheme
7 Fourier Transforms (Momentum Space) Root-Finding (Newton-Raphson, Bisection)

Problem 1: The Truncated Parabola in a Harmonic Oscillator

Problem Statement

Consider a particle of mass subject to a one-dimensional quantum harmonic oscillator potential:

At time , the particle is prepared in the initial state:

where and are positive real constants, and is the normalization constant.

Tasks
  1. Determine the normalization constant .
  2. Calculate the probability of finding the particle in the energy eigenstates .
  3. Write down the expression for the time-evolved wave function .

Solution & Dynamics

Analytical Solution

1. Finding the Normalization Constant

To normalize the wavefunction , we require the integral of its probability density over all space to equal :

Since the wavefunction is zero for , the integration limits are restricted to :

We expand the integrand and use the symmetry (even function) to double the integral from to :

Integrating term-by-term:

Substituting the upper limit :

Solving for (choosing the positive root):

2. Overlap Coefficients & Probabilities

The probability of measuring the energy eigenvalue is given by , where is the overlap integral of the initial state with the -th eigenstate:

The normalized eigenstates of the 1D quantum harmonic oscillator are: where .

  • Parity (Symmetry) Argument: The initial wavefunction is symmetric about the origin (even parity). The -th eigenfunction has the parity of .
    • For odd , is an odd function. The product of an even and an odd function is odd, making the integral over the symmetric interval vanish:
    • For even , is an even function, and the overlap is non-zero: Evaluating this integral analytically for general even yields complex expressions containing special functions. Thus, we compute it numerically using Simpson’s integration rule.
3. Time Evolution

The time-evolved wavefunction is constructed using the expansion:

Substituting for odd , this simplifies to a summation over even eigenstates: where .

Computational Solution

Below is the Python implementation that solves the normalization, computes the coefficients, plots the 2-panel physical dashboard, and renders the live interactive time-evolution of the wavefunction. We hardcode physical parameters representing an electron in an optical harmonic potential:

Code 
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from scipy.integrate import simpson
from scipy.special import eval_hermite, factorial
from IPython.display import HTML

# --- 1. Physical Parameters (SI Units) ---
A = 1.0
B = 1.38e18
m = 9.1e-31         # kg (electron mass)
omega = 1e15        # rad/s (angular frequency)
t_eval = 1.57e-15   # seconds (t = T/4)
n_max = 12          # number of eigenstates
hbar = 1.0545718e-34 # J.s

# Analytical Normalization Constant
N = (np.sqrt(15) * (B**0.25)) / (4 * (A**1.25))
# Natural length scale
l = np.sqrt(hbar / (m * omega))

# Spatial grid (dimensionless u = x/l)
x_max = 8 * l
x = np.linspace(-x_max, x_max, 5000)
dx = x[1] - x[0]
u = x / l

# Initial State
psi0 = np.zeros_like(x)
mask = x**2 <= (A / B)
psi0[mask] = N * (A - B * x[mask]**2)

# --- 2. Eigenfunction Coefficients ---
alpha = np.sqrt(m * omega / hbar)

def psi_n(n, x):
    norm = ((alpha**2 / np.pi)**0.25) / np.sqrt((2.0**n) * factorial(n))
    Hn = eval_hermite(n, alpha * x)
    return norm * Hn * np.exp(-0.5 * (alpha * x)**2)

coefficients = []
probabilities = []
energies = []

for n in range(n_max):
    psiN = psi_n(n, x)
    cn = simpson(psiN * psi0, x)
    Pn = np.abs(cn)**2
    En = (n + 0.5) * hbar * omega
    coefficients.append(cn)
    probabilities.append(Pn)
    energies.append(En)

coefficients = np.array(coefficients)
probabilities = np.array(probabilities)
energies = np.array(energies)

# Time Evolution at specified t_eval
psi_t = np.zeros_like(x, dtype=complex)
for n in range(n_max):
    phase = np.exp(-1j * energies[n] * t_eval / hbar)
    psi_t += coefficients[n] * psi_n(n, x) * phase

# --- 3. 2-Panel Plotting ---
phi0_scaled = psi0 * np.sqrt(l)
phit_scaled = psi_t * np.sqrt(l)
prob0_scaled = np.abs(phi0_scaled)**2
probt_scaled = np.abs(phit_scaled)**2

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 5), layout="constrained")
plot_colors = {
    'potential': '#64748b', 'initial_wf': '#94a3b8', 'evolved_wf_real': '#3b82f6',
    'evolved_wf_imag': '#f43f5e', 'evolved_prob': '#8b5cf6', 'grid': '#e2e8f0'
}

# Panel 1: Wavefunctions and Well
V_u = 0.5 * u**2
ax1.plot(u, V_u, color=plot_colors['potential'], ls='--', lw=1.5, label='Potential $V(u) = 0.5 u^2$')
ax1.fill_between(u, prob0_scaled, color=plot_colors['initial_wf'], alpha=0.15, label=r'$|\psi(u,0)|^2$ (Initial)')
ax1.plot(u, np.real(phit_scaled), color=plot_colors['evolved_wf_real'], lw=1.5, label=r'$\mathrm{Re}[\psi(u,t)]$')
ax1.plot(u, np.imag(phit_scaled), color=plot_colors['evolved_wf_imag'], lw=1.5, ls=':', label=r'$\mathrm{Im}[\psi(u,t)]$')
ax1.fill_between(u, probt_scaled, color=plot_colors['evolved_prob'], alpha=0.25, label=r'$|\psi(u,t)|^2$ (Evolved)')
ax1.set_xlim(-5, 5)
ax1.set_ylim(-1.2, 1.8)
ax1.set_title("Wavefunction Dynamics & Potential Well", fontsize=11, fontweight='semibold')
ax1.set_xlabel(r"Dimensionless Coordinate $u = x/l$")
ax1.set_ylabel("Amplitude / Probability Density")
ax1.grid(True, linestyle=':', alpha=0.6, color=plot_colors['grid'])
ax1.legend(loc='upper right', framealpha=0.9)
ax1.spines['top'].set_visible(False)
ax1.spines['right'].set_visible(False)

# Panel 2: Energy Spectrum
bars = ax2.bar(np.arange(n_max), probabilities, color=plot_colors['evolved_prob'], edgecolor='#7c3aed', alpha=0.8, width=0.5)
ax2.set_title("Energy Spectrum $|c_n|^2$", fontsize=11, fontweight='semibold')
ax2.set_xlabel("Quantum Number $n$")
ax2.set_ylabel("Probability $P_n$")
ax2.set_xticks(np.arange(n_max))
ax2.grid(True, linestyle=':', alpha=0.6, color=plot_colors['grid'], axis='y')
ax2.spines['top'].set_visible(False)
ax2.spines['right'].set_visible(False)

for bar in bars:
    height = bar.get_height()
    if height > 0.005:
        ax2.text(bar.get_x() + bar.get_width()/2.0, height + 0.01, f"{height:.3f}", ha='center', va='bottom', fontsize=8)

plt.show()

Left: Potential well V(u) along with the initial wavefunction (shaded gray) and time-evolved wavefunction (colored lines) at t = T/4. Right: Energy eigenstate probability spectrum.
Live Time Evolution Animation

The code below compiles a continuous time-evolution of the wavefunction over two periods (). The engine will render it inline as an interactive JavaScript player:

Code 
fig_anim, ax_anim = plt.subplots(figsize=(7, 4.5), layout="constrained")
ax_anim.set_xlim(-5, 5)
ax_anim.set_ylim(-1.2, 1.8)
ax_anim.set_title(r"Wavefunction Time Evolution $\psi(u, t)$", fontsize=11, fontweight='semibold')
ax_anim.set_xlabel(r"Dimensionless Coordinate $u = x/l$")
ax_anim.set_ylabel("Amplitude / Probability Density")
ax_anim.grid(True, linestyle=':', alpha=0.6, color=plot_colors['grid'])
ax_anim.spines['top'].set_visible(False)
ax_anim.spines['right'].set_visible(False)

# Background Potential Well
ax_anim.plot(u, V_u, color=plot_colors['potential'], ls='--', lw=1.5, label='Potential $V(u)$')

line_prob, = ax_anim.plot([], [], color=plot_colors['evolved_prob'], lw=2.2, label=r'$|\psi(u, t)|^2$')
line_real, = ax_anim.plot([], [], color=plot_colors['evolved_wf_real'], lw=1.3, label=r'$\mathrm{Re}[\psi(u, t)]$')
line_imag, = ax_anim.plot([], [], color=plot_colors['evolved_wf_imag'], lw=1.3, ls=':', label=r'$\mathrm{Im}[\psi(u, t)]$')
fill_coll = [ax_anim.fill_between([], [], color=plot_colors['evolved_prob'], alpha=0.15)]

time_text = ax_anim.text(
    0.05, 0.90, '', transform=ax_anim.transAxes, fontsize=9, fontweight='bold',
    bbox=dict(facecolor='white', alpha=0.9, edgecolor='#cbd5e1', boxstyle='round,pad=0.4')
)
ax_anim.legend(loc='upper right')

# Setup animation details (60 frames over 2 complete periods)
T_period = 2 * np.pi / omega
num_frames = 60
t_fracs = np.linspace(0, 2, num_frames)

def init():
    line_prob.set_data([], [])
    line_real.set_data([], [])
    line_imag.set_data([], [])
    time_text.set_text('')
    return line_prob, line_real, line_imag, time_text

def update(frame):
    t_frac = t_fracs[frame]
    t_val = t_frac * T_period
    
    # Calculate time-evolved wavefunction
    psi_t_anim = np.zeros_like(x, dtype=complex)
    for n in range(n_max):
        phase = np.exp(-1j * (n + 0.5) * omega * t_val)
        psi_t_anim += coefficients[n] * psi_n(n, x) * phase
        
    phi_t_anim = psi_t_anim * np.sqrt(l)
    prob_t_anim = np.abs(phi_t_anim)**2
    real_t_anim = np.real(phi_t_anim)
    imag_t_anim = np.imag(phi_t_anim)
    
    line_prob.set_data(u, prob_t_anim)
    line_real.set_data(u, real_t_anim)
    line_imag.set_data(u, imag_t_anim)
    
    fill_coll[0].remove()
    fill_coll[0] = ax_anim.fill_between(u, prob_t_anim, color=plot_colors['evolved_prob'], alpha=0.15)
    time_text.set_text(rf"$t = {t_frac:.2f}\,T$")
    return line_prob, line_real, line_imag, time_text

ani = animation.FuncAnimation(
    fig_anim, update, frames=num_frames, init_func=init, blit=False, interval=70
)

# Render Javascript player and suppress the static canvas output
html_str = ani.to_jshtml()
custom_css = """
.anim-buttons button[title="Decrease speed"],
.anim-buttons button[title="First frame"],
.anim-buttons button[title="Previous frame"],
.anim-buttons button[title="Play backwards"],
.anim-buttons button[title="Next frame"],
.anim-buttons button[title="Last frame"],
.anim-buttons button[title="Increase speed"] {
    display: none !important;
}
.anim-state input[type="radio"] {
    margin-right: 6px !important;
}
.anim-state label {
    margin-right: 20px !important;
}
"""
html_str = html_str.replace("</style>", f"{custom_css}\n</style>")
js_player = HTML(html_str)
plt.close(fig_anim)
js_player

Problem 2: The Shifted and Squeezed Gaussian

A particle of mass in a harmonic oscillator potential is initially prepared in a Gaussian wave packet given by: where is an initial spatial shift, is the initial width of the wave packet, and (which is the natural width of the oscillator ground state).

Tasks
  1. Determine the time evolution of the wave packet, .
  2. Calculate the expectation values of position and momentum .
  3. Determine the uncertainty in position and show how the wave packet width oscillates or “breathes” over time.

Solution & Dynamics

Analytical Solution

1. Time Evolution of Expectation Values

Using Ehrenfest’s Theorem for a particle in a harmonic oscillator potential , the expectation values obey classical equations of motion: Solving these coupled differential equations with initial conditions and yields: The center of the wave packet oscillates harmonically with frequency .

2. Position Uncertainty and “Breathing”

For a Gaussian wave packet, the uncertainty in position depends on its initial width . If the initial width differs from the natural width of the oscillator ground state , the state is “squeezed”. The time evolution of the variance is given by: Taking the square root gives the position uncertainty: This shows that the width of the wave packet oscillates (or “breathes”) with a frequency . If , the width remains constant (coherent state).

Computational Solution

We will compute the evolution numerically by expanding the Gaussian in the basis of harmonic oscillator eigenstates.

Code 
# --- 1. Physical Parameters ---
x0 = 3.0 * l        # initial shift
a = 0.5 * l         # squeezed width (narrower than ground state)
n_max2 = 40         # number of eigenstates for expansion
T_period = 2 * np.pi / omega

# Initial State
N_g = (np.pi * a**2)**(-0.25)
psi0_g = N_g * np.exp(-0.5 * ((x - x0)/a)**2)

# --- 2. Eigenfunction Coefficients ---
coefficients_g = []
for n in range(n_max2):
    psiN = psi_n(n, x)
    cn = simpson(psiN * psi0_g, x)
    coefficients_g.append(cn)
coefficients_g = np.array(coefficients_g)

# Time Evolution function
def get_psi_t_g(t_val):
    psi_t = np.zeros_like(x, dtype=complex)
    for n in range(n_max2):
        En = (n + 0.5) * hbar * omega
        phase = np.exp(-1j * En * t_val / hbar)
        psi_t += coefficients_g[n] * psi_n(n, x) * phase
    return psi_t

# --- 3. 2-Panel Plotting ---
t_half = T_period / 2.0
psi_half = get_psi_t_g(t_half)

fig2, (ax2_1, ax2_2) = plt.subplots(1, 2, figsize=(11, 5), layout="constrained")

# Panel 1: Wavefunctions and Well
ax2_1.plot(u, V_u, color=plot_colors['potential'], ls='--', lw=1.5, label='Potential $V(u)$')
ax2_1.fill_between(u, (np.abs(psi0_g)*np.sqrt(l))**2, color='#3b82f6', alpha=0.3, label=r'$|\psi(u,0)|^2$')
ax2_1.fill_between(u, (np.abs(psi_half)*np.sqrt(l))**2, color='#f43f5e', alpha=0.3, label=r'$|\psi(u,T/2)|^2$')
ax2_1.set_xlim(-6, 6)
ax2_1.set_ylim(-0.2, 2.5)
ax2_1.set_title("Wavepacket Bouncing in Potential", fontsize=11, fontweight='semibold')
ax2_1.set_xlabel(r"Dimensionless Coordinate $u = x/l$")
ax2_1.set_ylabel("Probability Density")
ax2_1.grid(True, linestyle=':', alpha=0.6)
ax2_1.legend(loc='upper center', framealpha=0.9)
ax2_1.spines['top'].set_visible(False)
ax2_1.spines['right'].set_visible(False)

# Panel 2: Expectation Values over Time
t_array = np.linspace(0, 1.5 * T_period, 100)
x_exp_comp, dx_comp = [], []
for t_val in t_array:
    pt = get_psi_t_g(t_val)
    prob_t = np.abs(pt)**2
    x_exp = simpson(x * prob_t, x)
    x2_exp = simpson(x**2 * prob_t, x)
    x_exp_comp.append(x_exp / l)
    dx_comp.append(np.sqrt(x2_exp - x_exp**2) / l)

# Analytical
x_exp_ana = (x0 / l) * np.cos(omega * t_array)
dx_ana = (a / (np.sqrt(2)*l)) * np.sqrt(np.cos(omega*t_array)**2 + (l/a)**4 * np.sin(omega*t_array)**2)

ax2_2.plot(t_array / T_period, x_exp_ana, 'k-', lw=2, label=r'Analytical $\langle x \rangle$')
ax2_2.plot(t_array / T_period, x_exp_comp, 'o', color='#3b82f6', markersize=4, label=r'Comp $\langle x \rangle$')
ax2_2.plot(t_array / T_period, dx_ana, 'k--', lw=2, label=r'Analytical $\Delta x$')
ax2_2.plot(t_array / T_period, dx_comp, 's', color='#f43f5e', markersize=3, label=r'Comp $\Delta x$')
ax2_2.set_title("Observables vs Time", fontsize=11, fontweight='semibold')
ax2_2.set_xlabel("Time $t/T$")
ax2_2.set_ylabel("Dimensionless Units")
ax2_2.grid(True, linestyle=':', alpha=0.6)
ax2_2.legend(loc='upper right')
ax2_2.spines['top'].set_visible(False)
ax2_2.spines['right'].set_visible(False)

plt.show()

Left: Potential well V(x) along with the initial and half-period wavefunctions. Right: Analytical vs Computational expectation value and position uncertainty.
Live Time Evolution Animation
Code 
fig_anim2, ax_anim2 = plt.subplots(figsize=(7, 4.5), layout="constrained")
ax_anim2.set_xlim(-6, 6)
ax_anim2.set_ylim(-0.2, 2.5)
ax_anim2.set_title(r"Squeezed Wavepacket Evolution $|\psi(u, t)|^2$", fontsize=11, fontweight='semibold')
ax_anim2.set_xlabel(r"Dimensionless Coordinate $u = x/l$")
ax_anim2.set_ylabel("Probability Density")
ax_anim2.grid(True, linestyle=':', alpha=0.6, color=plot_colors['grid'])
ax_anim2.spines['top'].set_visible(False)
ax_anim2.spines['right'].set_visible(False)

ax_anim2.plot(u, V_u, color='#64748b', ls='--', lw=1.5, label='Potential $V(u)$')
line_prob2, = ax_anim2.plot([], [], color='#8b5cf6', lw=2.2)
fill_coll2 = [ax_anim2.fill_between([], [], color='#8b5cf6', alpha=0.3)]
time_text2 = ax_anim2.text(0.05, 0.90, '', transform=ax_anim2.transAxes, fontsize=9, fontweight='bold', bbox=dict(facecolor='white', alpha=0.9, edgecolor='#cbd5e1', boxstyle='round,pad=0.4'))

num_frames2 = 60
t_fracs2 = np.linspace(0, 2, num_frames2)

def init2():
    line_prob2.set_data([], [])
    time_text2.set_text('')
    return line_prob2, time_text2

def update2(frame):
    t_frac = t_fracs2[frame]
    t_val = t_frac * T_period
    psi_t = get_psi_t_g(t_val)
    prob_t_anim = (np.abs(psi_t)*np.sqrt(l))**2
    
    line_prob2.set_data(u, prob_t_anim)
    fill_coll2[0].remove()
    fill_coll2[0] = ax_anim2.fill_between(u, prob_t_anim, color='#8b5cf6', alpha=0.3)
    time_text2.set_text(rf"$t = {t_frac:.2f}\,T$")
    return line_prob2, time_text2

ani2 = animation.FuncAnimation(fig_anim2, update2, frames=num_frames2, init_func=init2, blit=False, interval=70)
html_str2 = ani2.to_jshtml().replace("</style>", f"{custom_css}\n</style>")
js_player2 = HTML(html_str2)
plt.close(fig_anim2)
js_player2

Problem 3: Tunneling in the Quartic Double Well

A particle of mass moves in a one-dimensional quartic double-well potential described by: where and are positive constants.

Tasks
  1. Find the exact energy eigenvalues for the ground state () and the first excited state () using computational methods.
  2. Calculate the energy splitting .
  3. Determine the tunneling time for a particle initially localized in the right well to tunnel to the left well.

Solution & Dynamics

Analytical Solution

For a quartic double-well potential , there are two minima at .

1. Degeneracy and Splitting

When the barrier between the wells is high, the lowest two energy levels are nearly degenerate. The true ground state is symmetric, while the first excited state is antisymmetric: where and are states localized in the left and right wells, respectively. The energy splitting is small and determines the tunneling dynamics.

2. Tunneling Time

If a particle is initially localized entirely in the right well, the initial state is a superposition: The time evolution introduces a relative phase between the eigenstates: The particle completely tunnels to the left well when the relative phase reaches . This occurs at the tunneling time :

Computational Solution

To find the exact eigenvalues and eigenfunctions, we use the Finite Difference Method (FDM) to discretize the Schrödinger equation and turn it into a matrix eigenvalue problem (Hamiltonian diagonalization).

Code 
from scipy.sparse import diags
from scipy.sparse.linalg import eigsh

# --- 1. Physical Parameters ---
hbar_dw = 1.0
m_dw = 1.0
alpha_dw = 4.0
beta_dw = 0.5

# Spatial grid for Finite Difference
N_grid = 1000
x_dw = np.linspace(-4, 4, N_grid)
dx_dw = x_dw[1] - x_dw[0]

# Double Well Potential
V_dw = -0.5 * alpha_dw * x_dw**2 + beta_dw * x_dw**4

# --- 2. Matrix Diagonalization (FDM) ---
# Kinetic energy matrix (second derivative)
diag_main = 2.0 * np.ones(N_grid) / (dx_dw**2)
diag_off = -1.0 * np.ones(N_grid - 1) / (dx_dw**2)
T_mat = (hbar_dw**2 / (2 * m_dw)) * diags([diag_off, diag_main, diag_off], [-1, 0, 1])

# Potential energy matrix
V_mat = diags(V_dw, 0)

# Hamiltonian
H_mat = T_mat + V_mat

# Solve for smallest algebraic eigenvalues
eigenvalues, eigenvectors = eigsh(H_mat, k=6, which='SM')

E0, E1 = eigenvalues[0], eigenvalues[1]
psi0_dw = eigenvectors[:, 0] / np.sqrt(dx_dw) # Normalize
psi1_dw = eigenvectors[:, 1] / np.sqrt(dx_dw)

# Fix signs to be consistent
if psi0_dw[N_grid//2] < 0: psi0_dw *= -1
if psi1_dw[N_grid//4] < 0: psi1_dw *= -1

delta_E = E1 - E0
tau_tunnel = np.pi * hbar_dw / delta_E

# --- 3. 2-Panel Plotting ---
fig3, (ax3_1, ax3_2) = plt.subplots(1, 2, figsize=(11, 5), layout="constrained")

# Scale wavefunctions for visualization
scale_factor = 2.0
ax3_1.plot(x_dw, V_dw, color=plot_colors['potential'], ls='--', lw=1.5, label='Potential $V(x)$')
ax3_1.plot(x_dw, E0 + scale_factor * psi0_dw, color='#3b82f6', lw=1.5, label=f'$E_0$ (Sym)')
ax3_1.plot(x_dw, E1 + scale_factor * psi1_dw, color='#f43f5e', lw=1.5, label=f'$E_1$ (Anti-Sym)')
ax3_1.axhline(E0, color='#3b82f6', ls=':', alpha=0.5)
ax3_1.axhline(E1, color='#f43f5e', ls=':', alpha=0.5)

ax3_1.set_xlim(-3, 3)
ax3_1.set_ylim(-3, 2)
ax3_1.set_title("Quartic Double Well & Eigenstates", fontsize=11, fontweight='semibold')
ax3_1.set_xlabel(r"Coordinate $x$")
ax3_1.set_ylabel("Energy")
ax3_1.grid(True, linestyle=':', alpha=0.6)
ax3_1.legend(loc='lower center', framealpha=0.9)
ax3_1.spines['top'].set_visible(False)
ax3_1.spines['right'].set_visible(False)

# Spectrum
ax3_2.plot(np.zeros_like(eigenvalues), eigenvalues, '_', markersize=40, mew=2, color='#8b5cf6')
ax3_2.text(0.05, E0, f"$E_0 = {E0:.3f}$", va='center')
ax3_2.text(0.05, E1, f"$E_1 = {E1:.3f}$", va='center')
ax3_2.annotate('', xy=(0, E1), xytext=(0, E0), arrowprops=dict(arrowstyle='<->', color='black'))
ax3_2.text(-0.02, (E0+E1)/2, rf"$\Delta E = {delta_E:.4f}$", ha='right', va='center', fontweight='bold')

ax3_2.set_xlim(-0.1, 0.2)
ax3_2.set_ylim(-2.5, eigenvalues[-1] + 1)
ax3_2.set_title("Energy Spectrum", fontsize=11, fontweight='semibold')
ax3_2.set_xticks([])
ax3_2.set_ylabel("Energy")
ax3_2.grid(True, linestyle=':', alpha=0.6, axis='y')
ax3_2.spines['top'].set_visible(False)
ax3_2.spines['right'].set_visible(False)
ax3_2.spines['bottom'].set_visible(False)

plt.show()

Left: Double well potential and the lowest two eigenstates (symmetric and antisymmetric). Right: Zoomed-in energy spectrum showing the splitting .
Live Tunneling Animation
Code 
# Initial state localized in the right well
psi_R = (psi0_dw - psi1_dw) / np.sqrt(2)

fig_anim3, ax_anim3 = plt.subplots(figsize=(7, 4.5), layout="constrained")
ax_anim3.set_xlim(-3, 3)
ax_anim3.set_ylim(-3, 1)
ax_anim3.set_title(r"Quantum Tunneling Dynamics", fontsize=11, fontweight='semibold')
ax_anim3.set_xlabel(r"Coordinate $x$")
ax_anim3.set_ylabel("Energy / Probability")
ax_anim3.grid(True, linestyle=':', alpha=0.6, color=plot_colors['grid'])
ax_anim3.spines['top'].set_visible(False)
ax_anim3.spines['right'].set_visible(False)

ax_anim3.plot(x_dw, V_dw, color='#64748b', ls='--', lw=1.5)
line_prob3, = ax_anim3.plot([], [], color='#10b981', lw=2.2, label=r'$|\Psi(x,t)|^2$')
fill_coll3 = [ax_anim3.fill_between([], [], color='#10b981', alpha=0.3)]
time_text3 = ax_anim3.text(0.05, 0.90, '', transform=ax_anim3.transAxes, fontsize=9, fontweight='bold', bbox=dict(facecolor='white', alpha=0.9, edgecolor='#cbd5e1', boxstyle='round,pad=0.4'))
ax_anim3.legend(loc='upper center')

num_frames3 = 80
t_fracs3 = np.linspace(0, 2, num_frames3) # up to 2 * tau

def init3():
    line_prob3.set_data([], [])
    time_text3.set_text('')
    return line_prob3, time_text3

def update3(frame):
    t_frac = t_fracs3[frame]
    t_val = t_frac * tau_tunnel
    
    # Time evolution
    psi_t = (psi0_dw * np.exp(-1j * E0 * t_val / hbar_dw) - 
             psi1_dw * np.exp(-1j * E1 * t_val / hbar_dw)) / np.sqrt(2)
    prob_t = np.abs(psi_t)**2
    
    # Scale and shift to overlay on potential (visual purposes)
    viz_scale = 1.5
    prob_vis = (E0+E1)/2.0 + viz_scale * prob_t
    
    line_prob3.set_data(x_dw, prob_vis)
    fill_coll3[0].remove()
    fill_coll3[0] = ax_anim3.fill_between(x_dw, (E0+E1)/2.0, prob_vis, color='#10b981', alpha=0.3)
    time_text3.set_text(rf"$t = {t_frac:.2f}\,\tau$")
    return line_prob3, time_text3

ani3 = animation.FuncAnimation(fig_anim3, update3, frames=num_frames3, init_func=init3, blit=False, interval=70)
html_str3 = ani3.to_jshtml().replace("</style>", f"{custom_css}\n</style>")
js_player3 = HTML(html_str3)
plt.close(fig_anim3)
js_player3
]]> Quantum Physics Computational Physics Python Advanced Harmonic Oscillator https://physicsvoyage-github-io.pages.dev/Blog/Random_Physics/Quantum Dynamics.html Tue, 26 May 2026 08:00:00 GMT Computational Quantum Mechanics: Infinite Potential Well Aditya Kumar https://physicsvoyage-github-io.pages.dev/Blog/Random_Physics/Wavefunction.html

Problem Statement

A particle of mass moves freely inside a one-dimensional infinite potential well of length . The potential is:

The normalized energy eigenfunctions are:

with energy eigenvalues:

At time , the particle has the wavefunction:

where is a real constant. We are asked to:

  1. Find so that is normalized.
  2. Find all possible energy measurement outcomes, their probabilities, and the average energy .
  3. Find the wavefunction at any later time .

Part A — Normalization

Analytical Solution

The first step is to rewrite in terms of the orthonormal eigenfunctions .

Recall that . We factor this into each term:

Term 1:

Term 2:

Term 3:

So the state written cleanly in the eigenbasis is:

The coefficients are:

Normalization condition: The orthonormality of the eigenfunctions means , so:

Substituting:

With this, , and we can verify:

Computational Solution

Code 
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import quad

# --- Parameters ---
hbar = 1.0
m    = 1.0
a    = 1.0

# Eigenfunctions
def phi(n, x, a=1.0):
    return np.sqrt(2/a) * np.sin(n * np.pi * x / a)

# The wavefunction with unknown A
def psi0(x, A):
    return (A / np.sqrt(a)) * np.sin(np.pi * x / a) \
         + np.sqrt(3 / (5*a)) * np.sin(3 * np.pi * x / a) \
         + (1 / np.sqrt(5*a)) * np.sin(5 * np.pi * x / a)

# Numerical normalization integral
def norm_integral(A):
    result, _ = quad(lambda x: psi0(x, A)**2, 0, a)
    return result

A_analytical = np.sqrt(6/5)
norm_check = norm_integral(A_analytical)

print(f"Analytical A = sqrt(6/5) = {A_analytical:.6f}")
print(f"Normalization check: integral |psi|^2 dx = {norm_check:.8f}  (should be 1.0)")

# Extract coefficients
c1 = A_analytical / np.sqrt(2)
c3 = np.sqrt(3/10)
c5 = 1 / np.sqrt(10)
print(f"\nCoefficients:  c1 = {c1:.6f},  c3 = {c3:.6f},  c5 = {c5:.6f}")
print(f"Sum of |cn|^2  = {c1**2 + c3**2 + c5**2:.8f}  (should be 1.0)")

# --- Plot psi(x,0) and the three components ---
x = np.linspace(0, a, 500)

fig, ax = plt.subplots(figsize=(9, 4))
ax.plot(x, psi0(x, A_analytical), 'k-',  lw=2.5, label=r'$\psi(x,0)$')
ax.plot(x, c1 * phi(1, x),        '--',  lw=1.5, label=r'$c_1\phi_1$')
ax.plot(x, c3 * phi(3, x),        '--',  lw=1.5, label=r'$c_3\phi_3$')
ax.plot(x, c5 * phi(5, x),        '--',  lw=1.5, label=r'$c_5\phi_5$')
ax.set_xlabel('x / a')
ax.set_ylabel(r'$\psi(x,0)$')
ax.set_title('Initial Wavefunction and its Eigenfunction Components')
ax.legend()
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()
Analytical A = sqrt(6/5) = 1.095445
Normalization check: integral |psi|^2 dx = 1.00000000  (should be 1.0)

Coefficients:  c1 = 0.774597,  c3 = 0.547723,  c5 = 0.316228
Sum of |cn|^2  = 1.00000000  (should be 1.0)

The initial wavefunction (black) as a superposition of the first three odd eigenstates (colored dashed lines).
Understanding the Graph
  • The solid black line shows how the total wavefunction is built by adding the three individual states (dashed lines).
  • The ground state () provides the main shape, while and add the extra wiggles.
  • Because the function is normalized, the total area under the black curve squared is exactly 1.

Part B — Energy Measurements

Analytical Solution

In quantum mechanics, the Born rule states that if we measure energy on a state

the probability of getting the result is .

Our state has three contributions, so only three energy values are possible:

Eigenstate Energy Coefficient Probability

Verification:

Average (expectation value) of energy:

Computational Solution

Code 
# --- Part B: Energy measurements ---

E1 = (np.pi**2 * hbar**2) / (2 * m * a**2)  # Ground state energy

energies = {
    'n=1 (E1)':   (1,  E1,     c1**2),
    'n=3 (9E1)':  (3,  9*E1,   c3**2),
    'n=5 (25E1)': (5,  25*E1,  c5**2),
}

print("=" * 55)
print(f"{'State':<12} {'Energy':>12}  {'Probability':>12}")
print("=" * 55)
for label, (n, E, P) in energies.items():
    print(f"  {label:<10}  {E:>12.6f}  {P:>12.6f}")
print("-" * 55)

E_avg = sum(P * E for _, (n, E, P) in energies.items())
E_avg_analytical = 29 * E1 / 5

print(f"  {'<E> (numerical)':<22} {E_avg:.6f}")
print(f"  {'<E> (29/5 x E1)':<22} {E_avg_analytical:.6f}")
print("=" * 55)

# Bar chart of probabilities
fig, ax = plt.subplots(figsize=(6, 4))
ns     = [1, 3, 5]
probs  = [c1**2, c3**2, c5**2]
labels = [r'$E_1$', r'$9E_1$', r'$25E_1$']

bars = ax.bar(labels, probs, color=['#4C72B0','#DD8452','#55A868'], width=0.4, edgecolor='k')
for bar, p in zip(bars, probs):
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
            f'{p:.2f}', ha='center', va='bottom', fontsize=11, fontweight='bold')

ax.axhline(1, color='gray', lw=0.8, ls='--', alpha=0.5)
ax.set_ylim(0, 1.1)
ax.set_xlabel('Energy Eigenvalue')
ax.set_ylabel('Probability')
ax.set_title('Probability of Each Energy Measurement Outcome')
ax.grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.show()
=======================================================
State              Energy   Probability
=======================================================
  n=1 (E1)        4.934802      0.600000
  n=3 (9E1)      44.413220      0.300000
  n=5 (25E1)    123.370055      0.100000
-------------------------------------------------------
  <E> (numerical)        28.621853
  <E> (29/5 x E1)        28.621853
=======================================================

Probability of measuring each energy eigenvalue for the given state.

Part C — Time Evolution

Analytical Solution

In quantum mechanics, time evolution is governed by the Time-Dependent Schrodinger Equation (TDSE):

When a state is expanded in energy eigenfunctions, each eigenfunction simply picks up a phase factor :

For our state, this gives:

where .

The probability density at time is:

Expanding the squared modulus introduces interference terms that oscillate in time:

This shows that the probability density breathes and shifts in time — the quantum state is alive even though the energy probabilities never change.

The characteristic oscillation period between levels and is:

Computational Solution — Time Evolution Visualisation

Explore different times

Change the value of t_in_T1 below to see at different moments. The value is in units of .

Code 
# --- Parameters ---
E1 = (np.pi**2 * hbar**2) / (2 * m * a**2)
T1 = 2 * np.pi * hbar / E1   # Natural period of ground state

def phi_n(n, x):
    return np.sqrt(2/a) * np.sin(n * np.pi * x / a)

def psi_t(x, t):
    """Full time-dependent wavefunction (complex)."""
    c1 = np.sqrt(3/5)
    c3 = np.sqrt(3/10)
    c5 = 1 / np.sqrt(10)
    return (c1 * phi_n(1, x) * np.exp(-1j * E1     * t / hbar)
          + c3 * phi_n(3, x) * np.exp(-1j * 9*E1   * t / hbar)
          + c5 * phi_n(5, x) * np.exp(-1j * 25*E1  * t / hbar))

# =========================================================
# Change this value to explore different times
# =========================================================
t_in_T1 = 0.25    # time in units of T1
t = t_in_T1 * T1
# =========================================================

x = np.linspace(0, a, 1000)
Psi_t  = psi_t(x, t)
prob_t = np.abs(Psi_t)**2
prob_0 = np.abs(psi_t(x, 0))**2

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# Left: Probability density
ax = axes[0]
ax.plot(x, prob_0, 'k--', lw=1.5, alpha=0.5, label=r'$|\psi(x,0)|^2$  (reference)')
ax.plot(x, prob_t, 'b-',  lw=2.5, label=rf'$|\psi(x,t)|^2$  at $t = {t_in_T1:.3f}\,T_1$')
ax.fill_between(x, prob_t, alpha=0.15, color='blue')
ax.set_xlabel('x / a', fontsize=12)
ax.set_ylabel(r'$|\psi(x,t)|^2$', fontsize=12)
ax.set_title(rf'Probability Density at $t = {t_in_T1:.3f}\,T_1$', fontsize=13)
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

# Right: Real and imaginary parts of psi(x,t)
ax2 = axes[1]
ax2.plot(x, np.real(Psi_t), 'royalblue', lw=2, label=r'Re$[\psi(x,t)]$')
ax2.plot(x, np.imag(Psi_t), 'crimson',   lw=2, label=r'Im$[\psi(x,t)]$')
ax2.axhline(0, color='k', lw=0.8)
ax2.set_xlabel('x / a', fontsize=12)
ax2.set_ylabel(r'$\psi(x,t)$', fontsize=12)
ax2.set_title(rf'Real \& Imaginary Parts at $t = {t_in_T1:.3f}\,T_1$', fontsize=13)
ax2.legend(fontsize=10)
ax2.grid(alpha=0.3)

plt.suptitle(rf'Time Evolution of Infinite Well Superposition — $t = {t_in_T1:.3f}\,T_1$',
             fontsize=13, fontweight='bold', y=1.02)
plt.tight_layout()
plt.show()

Probability density and real/imaginary parts of the wavefunction at time .
Code 
# --- Bonus: Animated time sweep ---
# Plots |psi(x,t)|^2 for t from 0 to T1 in 200 steps to show the "breathing"

times = np.linspace(0, T1, 200)
x     = np.linspace(0, a, 500)

fig, ax = plt.subplots(figsize=(9, 4))
cmap = plt.cm.plasma

for i, t_val in enumerate(times):
    color = cmap(i / len(times))
    ax.plot(x, np.abs(psi_t(x, t_val))**2, color=color, lw=0.8, alpha=0.6)

# Overlay t=0 and t=T1/2 prominently
ax.plot(x, np.abs(psi_t(x, 0))**2,      'white', lw=2.5, label=r'$t=0$')
ax.plot(x, np.abs(psi_t(x, T1/2))**2,   'yellow', lw=2.5, linestyle='--', label=r'$t=T_1/2$')
ax.plot(x, np.abs(psi_t(x, T1))**2,     'cyan',   lw=2.5, linestyle=':', label=r'$t=T_1$')

ax.set_facecolor('#0d0d0d')
fig.patch.set_facecolor('#0d0d0d')
ax.tick_params(colors='white')
ax.xaxis.label.set_color('white')
ax.yaxis.label.set_color('white')
ax.title.set_color('white')
for spine in ax.spines.values():
    spine.set_edgecolor('white')

ax.set_xlabel('x / a', fontsize=12)
ax.set_ylabel(r'$|\psi(x,t)|^2$', fontsize=12)
ax.set_title(r'Time Evolution of Probability Density ($0 \to T_1$)', fontsize=13)
ax.legend(fontsize=10, facecolor='#1a1a1a', labelcolor='white')
ax.grid(alpha=0.2)
plt.tight_layout()
plt.show()

Animated sweep showing the time evolution of the probability density from to .
What’s happening in these graphs?
  • Taking a Snapshot: The first graph acts like a camera taking a picture at a specific time. It shows what the wave looks like at that exact moment.
  • Time-Lapse Motion: The second graph shows the wave changing over a full time cycle. The different colors show the wave at different times.
  • The “Breathing” Effect: Notice how the wave sloshes back and forth! This happens because the different simple waves that make up the total wave are vibrating at different speeds, causing them to interfere with each other.

Summary

Part A Part B Part C
Goal Normalize Energy measurements Time evolution
Key tool Orthonormality of Born rule Phase factors
Result oscillates, constant
Key Physical Insight

Even though the probability of measuring each energy never changes (energy probabilities are stationary), the probability density does change in time due to interference between the different eigenstates. The particle’s position is genuinely time-dependent, even in a stationary potential.

References

  1. Zettili, N. Quantum Mechanics: Concepts and Applications, 2nd ed. Wiley, 2009.
  2. Griffiths, D.J. Introduction to Quantum Mechanics, 3rd ed. Cambridge, 2018.
]]> Quantum Mechanics Computational Physics Python Infinite Potential Well https://physicsvoyage-github-io.pages.dev/Blog/Random_Physics/Wavefunction.html Mon, 25 May 2026 10:00:00 GMT Introduction to Computational Physics Aditya Kumar https://physicsvoyage-github-io.pages.dev/Blog/Subjects/Intro_Comp_Physics/

Why Does Computational Physics Exist?

Physics has always had two engines: theory and experiment. Theory gives us equations — Maxwell’s equations, the Schrödinger equation, the Einstein field equations. Experiment tells us whether those equations describe reality.

For most of human history, that was enough. You derived an equation, solved it analytically, made a prediction, tested it. The workflow was clean.

Then the problems got harder.

The Schrödinger equation for a single hydrogen atom has an exact analytical solution. The Schrödinger equation for two electrons — helium — already requires approximations. For ten electrons? Forget closed forms. For the electrons in a piece of copper? The exact wavefunction of that system lives in a Hilbert space so vast that writing it down would require more information than atoms in the observable universe.

This is where computational physics enters the picture. It is the third engine — the one that fills the gap between “we have an equation” and “we can’t solve it analytically.”

What Computational Physics Actually Is

Computational physics is not just “physics done on a computer.” It is a discipline with its own methods, its own aesthetics, its own failure modes.

At its core, it is about discretisation — taking the continuous language of physics (differential equations, integrals, infinite Hilbert spaces) and translating it into a finite set of numbers that a machine can manipulate.

Consider the simplest example. The heat equation:

This describes how temperature spreads through a rod over time. Analytically, we can solve it for simple boundary conditions. But for a rod with complicated geometry, weird materials, or time-varying boundaries? Analytically intractable.

Computationally, we discretise the rod into a grid of points , and the time into steps . Then we replace the derivatives with finite differences:

Now instead of a differential equation, we have an algebraic update rule — something a computer can apply millions of times per second.

That replacement — continuous → discrete, differential → algebraic — is the fundamental act of computational physics.

The Four Pillars

Most of computational physics sits on four broad methods:

1. Finite Difference & Finite Element Methods (FDM / FEM)

For differential equations on grids. This is how we simulate fluid flow, heat transfer, electromagnetic fields in complex geometries, and elastic materials. The idea is always the same: discretise space (and time), replace derivatives with differences, iterate.

2. Molecular Dynamics (MD)

For systems of interacting particles. We apply Newton’s second law to every particle at every timestep: , update positions and velocities. This is how we simulate proteins folding, materials fracturing, plasmas evolving.

3. Monte Carlo Methods

For problems where the answer is an integral over an enormous space, and exact methods are impossible. Instead of integrating everywhere, we sample randomly — and the law of large numbers guarantees we converge to the right answer. Monte Carlo is how we compute path integrals in quantum field theory, study phase transitions, and price financial derivatives.

4. Matrix / Linear Algebra Methods

For quantum mechanics especially. The Hamiltonian of a quantum system is a matrix (or an operator that we represent as one). Finding energy levels means diagonalising that matrix. For small systems we do this exactly — this is exact diagonalisation (ED). For large systems we use approximate methods: Lanczos algorithms, DMRG, tensor networks.

A First Example: The Harmonic Oscillator

Let’s make this concrete. The harmonic oscillator — a mass on a spring — has the equation of motion:

We know the analytic solution: . But let’s solve it numerically anyway, to see the method.

We convert the second-order ODE into two first-order ODEs:

Then we use the Euler method — the simplest possible numerical integrator:

In Python:

import numpy as np
import matplotlib.pyplot as plt

# Parameters
omega = 2 * np.pi   # angular frequency (1 Hz oscillation)
dt    = 0.01        # timestep — smaller = more accurate
T     = 5.0         # total simulation time in seconds
steps = int(T / dt)

# Initial conditions
x = 1.0   # initial position (amplitude = 1)
v = 0.0   # starting from rest

# Storage arrays
x_vals = np.zeros(steps)
t_vals = np.linspace(0, T, steps)

# Euler integration loop
for i in range(steps):
    x_vals[i] = x           # record current position
    x_new = x + v * dt      # update position
    v_new = v - omega**2 * x * dt   # update velocity
    x, v  = x_new, v_new    # advance state

# Analytical solution for comparison
x_exact = np.cos(omega * t_vals)

# Plot
plt.figure(figsize=(10, 4))
plt.plot(t_vals, x_vals,  label='Euler (numerical)', linewidth=2)
plt.plot(t_vals, x_exact, label='Exact solution',    linewidth=2, linestyle='--')
plt.xlabel('Time (s)')
plt.ylabel('Position x(t)')
plt.title('Harmonic Oscillator — Euler vs Exact')
plt.legend()
plt.tight_layout()
plt.show()

Run this and you’ll immediately see a problem: the Euler solution slowly drifts away from the exact answer. The amplitude grows over time — the oscillator appears to gain energy from nowhere.

This is not a bug in your code. It is a fundamental property of the Euler method: it does not conserve energy. For oscillatory systems, this is catastrophic.

The fix? Use a symplectic integrator — the simplest one is called the Symplectic Euler (or Euler-Cromer) method. The only change is that you use the updated velocity when computing the new position:

# Symplectic Euler — just swap the order of updates
v_new = v - omega**2 * x * dt   # update velocity FIRST
x_new = x + v_new * dt           # use NEW velocity for position

This tiny reordering makes the method energy-conserving over long times. The physics is now correct.

Why This Matters: The Bigger Picture

The harmonic oscillator example teaches something much deeper than numerics. It shows that the choice of algorithm is a physics choice, not just a software engineering choice.

Different integrators preserve different things: - Euler preserves nothing (energy drifts) - Symplectic Euler preserves a modified Hamiltonian (energy stays bounded) - Runge-Kutta 4 is more accurate per step but still not symplectic - Verlet / leapfrog are symplectic and time-reversible — used in molecular dynamics

When you choose an algorithm, you are choosing which physical properties your simulation will respect. Get it wrong and your results are fiction — plausible-looking, reproducible fiction.

This is what distinguishes computational physics from computational numerics. We are not just solving equations. We are trying to faithfully represent physical systems, and that requires physical understanding at every step.

What Comes Next

This post is the beginning of a series I’m calling Code and Quanta — a public working log of learning computational physics from the ground up. No library shortcuts, no black boxes. Everything built from the first principles of the problem.

Upcoming topics in this series:

Post Topic
2 The Laplacian on a Grid — finite difference PDE solver
3 Exact Diagonalisation of the Ising model
4 Monte Carlo integration and the Metropolis algorithm
5 The Lanczos algorithm — finding ground states of large Hamiltonians

Each post will include working Python code, derivations of the key equations, and honest commentary on what went wrong before it went right.

If you spot an error, disagree with an interpretation, or have a better algorithm — leave a comment or reach out directly. This notebook is public precisely because I expect to be corrected.

Further Reading

For those who want to go deeper right now:

  • Numerical Recipes (Press et al.) — the classic reference for numerical methods in science
  • Computational Physics by Nicholas Giordano & Hisao Nakanishi — a gentle, physics-first introduction
  • Quantum Many-Body Physics by Naoki Kawashima — for where this series is eventually heading
  • The SciPy documentation — particularly scipy.integrate and scipy.linalg

This is post 1 of the Code and Quanta series. All code in this series is MIT licensed.

]]> Computational Physics Beginner Python https://physicsvoyage-github-io.pages.dev/Blog/Subjects/Intro_Comp_Physics/ Fri, 22 May 2026 00:00:00 GMT