Are the courses on CoursesHub.World free?

Yes, all courses on CoursesHub.World are completely free and open access. We believe in democratizing education and making university-level science courses available to everyone worldwide.

What subjects are covered on CoursesHub.World?

CoursesHub.World offers courses in physics (Quantum Mechanics, General Relativity, QFT, Plasma Physics, Cosmology), biology (Molecular Biology, Cell Physiology, Pharmacology), and earth sciences (Oceanography, Atmospheric Science, Climatology).

What level are the courses?

Our courses are designed at the graduate and advanced undergraduate level. They include rigorous mathematical derivations and are suitable for physics students, researchers, and serious self-learners.

Where do the video lectures come from?

Our 400+ video lectures come from world-renowned sources including MIT OpenCourseWare, Stanford, lectures by Nobel laureates, and other leading universities and educators.

Quantum Mechanics Programs

Interactive Python simulations for quantum mechanics — inspired by qmsolve

These simulations run entirely in your browser using Pyodide (WebAssembly Python). For advanced 3D visualizations and GPU-accelerated computations, install qmsolve locally.

These programs use the same numerical methods as qmsolve (split-step Fourier, eigenstate solvers) but run directly in your browser. The first run downloads the Python environment (~15MB). Click "Run" to execute!

1D Harmonic Oscillator

Solve the quantum harmonic oscillator analytically. Visualize eigenstates, probability densities, and energy levels. Uses Hermite polynomials and demonstrates the equally-spaced energy spectrum E_n = (n+1/2)hbar*omega.

import numpy as np
import matplotlib.pyplot as plt
from math import factorial

# 1D Quantum Harmonic Oscillator - Eigenstates
# Inspired by qmsolve (github.com/quantum-visualizations/qmsolve)

# Hermite polynomials via recurrence: H_0=1, H_1=2x, H_{n+1}=2x*H_n - 2n*H_{n-1}
def hermite_val(n, x):
    """Evaluate physicist's Hermite polynomial H_n(x) using recurrence"""
    if n == 0:
        return np.ones_like(x)
    elif n == 1:
        return 2.0 * x
    H_prev, H_curr = np.ones_like(x), 2.0 * x
    for k in range(1, n):
        H_prev, H_curr = H_curr, 2.0 * x * H_curr - 2.0 * k * H_prev
    return H_curr

# Physical parameters (in natural units: hbar = m = omega = 1)
hbar = 1.0
m = 1.0
omega = 1.0

# Spatial grid
x = np.linspace(-6, 6, 500)

# Analytic wavefunctions: psi_n(x) = N_n * H_n(alpha*x) * exp(-alpha^2 x^2 / 2)
# where alpha = sqrt(m*omega/hbar), N_n = normalization, H_n = Hermite polynomial

alpha = np.sqrt(m * omega / hbar)

def psi_n(n, x):
    """Quantum harmonic oscillator eigenstate n"""
    H_n = hermite_val(n, alpha * x)
    N_n = (alpha / np.pi**0.5 / (2**n * factorial(n)))**0.5
    return N_n * H_n * np.exp(-alpha**2 * x**2 / 2)

def E_n(n):
    """Energy of eigenstate n"""
    return hbar * omega * (n + 0.5)

# Potential
V = 0.5 * m * omega**2 * x**2

# Plot first 6 eigenstates
n_states = 6
fig, axes = plt.subplots(1, 3, figsize=(15, 6))

# --- Left: Wavefunctions offset by energy ---
ax1 = axes[0]
colors = plt.cm.viridis(np.linspace(0.2, 0.9, n_states))

ax1.plot(x, V, 'w--', alpha=0.4, linewidth=1.5, label='V(x)')
for n in range(n_states):
    psi = psi_n(n, x)
    energy = E_n(n)
    ax1.fill_between(x, energy, energy + psi * 1.5, alpha=0.3, color=colors[n])
    ax1.plot(x, energy + psi * 1.5, color=colors[n], linewidth=1.5, label=f'n={n}, E={energy:.1f}')
    ax1.axhline(y=energy, color=colors[n], linestyle=':', alpha=0.3)

ax1.set_xlim(-5, 5)
ax1.set_ylim(-0.5, n_states * hbar * omega + 1)
ax1.set_xlabel('Position x', color='white', fontsize=11)
ax1.set_ylabel('Energy / Wavefunction', color='white', fontsize=11)
ax1.set_title('Wavefunctions (offset by energy)', fontsize=13, color='#c084fc')
ax1.legend(fontsize=7, facecolor='#1e293b', edgecolor='gray', labelcolor='white', loc='upper right')
ax1.set_facecolor('#1e293b')
ax1.tick_params(colors='white')
for spine in ax1.spines.values():
    spine.set_color('gray')
ax1.grid(True, alpha=0.2)

# --- Center: Probability densities ---
ax2 = axes[1]
for n in range(n_states):
    psi = psi_n(n, x)
    prob = np.abs(psi)**2
    ax2.plot(x, prob, color=colors[n], linewidth=1.8, label=f'|psi_{n}|^2')

ax2.set_xlim(-5, 5)
ax2.set_xlabel('Position x', color='white', fontsize=11)
ax2.set_ylabel('Probability Density |psi|^2', color='white', fontsize=11)
ax2.set_title('Probability Densities', fontsize=13, color='#c084fc')
ax2.legend(fontsize=8, facecolor='#1e293b', edgecolor='gray', labelcolor='white')
ax2.set_facecolor('#1e293b')
ax2.tick_params(colors='white')
for spine in ax2.spines.values():
    spine.set_color('gray')
ax2.grid(True, alpha=0.2)

# --- Right: Energy level diagram ---
ax3 = axes[2]
for n in range(n_states):
    energy = E_n(n)
    ax3.hlines(energy, 0, 1, colors=colors[n], linewidth=3)
    ax3.text(1.1, energy, f'n={n}: E = {energy:.1f} hbar*omega', color=colors[n], fontsize=10, va='center')

ax3.set_xlim(-0.5, 3.5)
ax3.set_ylim(-0.5, n_states * hbar * omega + 1)
ax3.set_ylabel('Energy (hbar * omega)', color='white', fontsize=11)
ax3.set_title('Energy Levels', fontsize=13, color='#c084fc')
ax3.set_facecolor('#1e293b')
ax3.tick_params(colors='white')
ax3.set_xticks([])
for spine in ax3.spines.values():
    spine.set_color('gray')

plt.tight_layout()
plt.show()

print("Quantum Harmonic Oscillator - Eigenstates")
print("=" * 50)
print(f"Parameters: hbar={hbar}, m={m}, omega={omega}")
print(f"alpha = sqrt(m*omega/hbar) = {alpha:.4f}")
print()
for n in range(n_states):
    print(f"  n={n}: E_{n} = {E_n(n):.2f} hbar*omega")
print()
print("Equal energy spacing: Delta E = hbar * omega = 1.0")
print("Zero-point energy: E_0 = hbar * omega / 2 = 0.5")

Click Run to execute the Python code

First run will download Python environment (~15MB)

Fundamental Equations of Quantum Mechanics

The Schrodinger Equation

The fundamental equation governing quantum mechanical systems:

Time-Dependent Schrodinger Equation:

$$i\hbar \frac{\partial}{\partial t} \Psi(\mathbf{r}, t) = \hat{H} \Psi(\mathbf{r}, t)$$

Time-Independent Schrodinger Equation:

$$\hat{H} \psi(\mathbf{r}) = E \psi(\mathbf{r})$$

where $ \hat{H} = -\frac{\hbar^2}{2m}\nabla^2 + V(\mathbf{r}) $

Split-Step Fourier Method (used in tunneling & double-slit simulations):

$$\Psi(t+\Delta t) \approx e^{-i\hat{V}\Delta t/2\hbar} \cdot \mathcal{F}^{-1}\!\left[e^{-i\hbar k^2\Delta t/2m}\cdot\mathcal{F}\!\left[e^{-i\hat{V}\Delta t/2\hbar}\Psi(t)\right]\right]$$

Harmonic Oscillator

$$E_n = \hbar\omega\!\left(n + \tfrac{1}{2}\right), \quad n = 0, 1, 2, \ldots$$

Wavefunctions:

$$\psi_n(x) = \left(\frac{\alpha}{\sqrt{\pi}\,2^n n!}\right)^{1/2} H_n(\alpha x)\,e^{-\alpha^2 x^2/2}$$

Infinite Square Well

$$E_n = \frac{n^2 \pi^2 \hbar^2}{2mL^2}, \quad n = 1, 2, 3, \ldots$$

Wavefunctions:

$$\psi_n(x) = \sqrt{\frac{2}{L}}\,\sin\!\left(\frac{n\pi x}{L}\right)$$

Hydrogen Atom

Energy levels:

$$E_n = -\frac{13.6 \text{ eV}}{n^2}$$

Radial wavefunction:

$$R_{nl}(r) = N_{nl}\,e^{-r/na_0}\left(\frac{2r}{na_0}\right)^l L_{n-l-1}^{2l+1}\!\left(\frac{2r}{na_0}\right)$$

Quantum numbers:

$ n = 1, 2, 3, \ldots $ — principal quantum number

$ l = 0, 1, \ldots, n{-}1 $ — angular momentum

$ m = -l, \ldots, +l $ — magnetic quantum number

Tunneling probability (rectangular barrier):

$$T \approx e^{-2\kappa a}, \quad \kappa = \frac{\sqrt{2m(V_0 - E)}}{\hbar}$$

About qmsolve

The simulations on this page are inspired by qmsolve, a Python module for solving and visualizing the Schrodinger equation. For more advanced capabilities, install it locally:

# Basic installation

pip install qmsolve

# With 3D volumetric visualization (Mayavi)

pip install qmsolve[with_mayavi]

Eigenstate Solver

Solves for eigenstates of 1D, 2D, and 3D systems using ARPACK's Lanczos method and LOBPCG. Handles single and two-particle systems.

Time-Dependent Solver

Split-step Fourier and Cayley-Crank-Nicolson methods for time evolution. Supports complex potentials and momentum-dependent interactions.

3D Visualization

Volumetric rendering via Mayavi, interactive eigenstate exploration with sliders, and GPU acceleration through CuPy/CUDA.

Quick Example

from qmsolve import Hamiltonian, SingleParticle, TimeSimulation
from qmsolve.util.constants import eV, Å

def harmonic_oscillator(particle):
    k = 100. * eV / Å**2
    return 0.5 * k * particle.x**2

H = Hamiltonian(
    particles=SingleParticle(),
    potential=harmonic_oscillator,
    spatial_ndim=1, N=512, extent=20*Å
)

eigenstates = H.solve(max_states=30)
eigenstates.visualize(show=True)

Quantum Mechanics Course