jupyterlab-codex-sidebar 0.1.4 → 0.1.6

package/tests/e2e/fixtures/notebooks/tab3.ipynb

@@ -0,0 +1,403 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "tab3-cell",
+   "metadata": {
+    "lines_to_next_cell": 1
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee23365d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1D time-dependent Schrodinger equation simulation (hbar = m = 1).\n",
+    "# Method: split-operator (FFT), which keeps time evolution numerically stable.\n",
+    "\n",
+    "def split_operator_step(psi_state, phase_v_half, phase_t):\n",
+    "    # One split-operator update: V/2 -> T -> V/2\n",
+    "    psi_state = phase_v_half * psi_state\n",
+    "    psi_k_state = np.fft.fft(psi_state)\n",
+    "    psi_k_state *= phase_t\n",
+    "    psi_state = np.fft.ifft(psi_k_state)\n",
+    "    psi_state = phase_v_half * psi_state\n",
+    "    return psi_state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f816d05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Simulation helpers\n",
+    "def _validate_simulation_params(\n",
+    "    hbar, mass, grid_size, x_min, x_max, dt, steps, save_every, sigma, barrier_width, barrier_region\n",
+    "):\n",
+    "    if grid_size <= 0:\n",
+    "        raise ValueError(\"grid_size must be positive.\")\n",
+    "    if x_max <= x_min:\n",
+    "        raise ValueError(\"x_max must be greater than x_min.\")\n",
+    "    if dt <= 0:\n",
+    "        raise ValueError(\"dt must be positive.\")\n",
+    "    if steps < 0:\n",
+    "        raise ValueError(\"steps must be non-negative.\")\n",
+    "    if save_every <= 0:\n",
+    "        raise ValueError(\"save_every must be positive.\")\n",
+    "    if mass <= 0:\n",
+    "        raise ValueError(\"mass must be positive.\")\n",
+    "    if hbar <= 0:\n",
+    "        raise ValueError(\"hbar must be positive.\")\n",
+    "    if sigma <= 0:\n",
+    "        raise ValueError(\"sigma must be positive.\")\n",
+    "    if barrier_width <= 0:\n",
+    "        raise ValueError(\"barrier_width must be positive.\")\n",
+    "    if barrier_region < 0:\n",
+    "        raise ValueError(\"barrier_region must be non-negative.\")\n",
+    "\n",
+    "\n",
+    "def _initialize_system(\n",
+    "    hbar, mass, grid_size, x_min, x_max, dt, barrier_height, barrier_width, x0, sigma, k0\n",
+    "):\n",
+    "    x = np.linspace(x_min, x_max, grid_size, endpoint=False)\n",
+    "    dx = x[1] - x[0]\n",
+    "    k = 2.0 * np.pi * np.fft.fftfreq(grid_size, d=dx)\n",
+    "\n",
+    "    V = barrier_height * np.exp(-(x / barrier_width) ** 2)\n",
+    "    psi = np.exp(-((x - x0) ** 2) / (2.0 * sigma**2)) * np.exp(1j * k0 * x)\n",
+    "    psi /= np.sqrt(np.sum(np.abs(psi) ** 2) * dx)\n",
+    "\n",
+    "    phase_v_half = np.exp(-1j * V * dt / (2.0 * hbar))\n",
+    "    T_k = (hbar**2) * (k**2) / (2.0 * mass)\n",
+    "    phase_t = np.exp(-1j * T_k * dt / hbar)\n",
+    "    return x, dx, k, V, psi, phase_v_half, phase_t\n",
+    "\n",
+    "\n",
+    "def _record_observables(psi, x, dx, k, hbar):\n",
+    "    density = np.abs(psi) ** 2\n",
+    "    norm = np.sum(density) * dx\n",
+    "\n",
+    "    x_mean = np.sum(x * density) * dx\n",
+    "    x2_mean = np.sum((x**2) * density) * dx\n",
+    "    psi_k = np.fft.fft(psi)\n",
+    "    p_psi = np.fft.ifft(hbar * k * psi_k)\n",
+    "    p2_psi = np.fft.ifft((hbar * k) ** 2 * psi_k)\n",
+    "    p_mean = np.real(np.sum(np.conj(psi) * p_psi) * dx)\n",
+    "    p2_mean = np.real(np.sum(np.conj(psi) * p2_psi) * dx)\n",
+    "\n",
+    "    x_var = max(x2_mean - x_mean**2, 0.0)\n",
+    "    p_var = max(p2_mean - p_mean**2, 0.0)\n",
+    "    uncertainty = np.sqrt(x_var) * np.sqrt(p_var)\n",
+    "    return density, norm, x_mean, p_mean, uncertainty\n",
+    "\n",
+    "\n",
+    "def _compute_diagnostics(final_density, x, dx, barrier_region, uncertainty_history):\n",
+    "    reflection = np.sum(final_density[x < -barrier_region]) * dx\n",
+    "    transmission = np.sum(final_density[x > barrier_region]) * dx\n",
+    "    near_barrier = np.sum(final_density[np.abs(x) <= barrier_region]) * dx\n",
+    "\n",
+    "    return {\n",
+    "        \"final_norm\": np.sum(final_density) * dx,\n",
+    "        \"reflection\": reflection,\n",
+    "        \"transmission\": transmission,\n",
+    "        \"near_barrier\": near_barrier,\n",
+    "        \"probability_sum\": reflection + transmission + near_barrier,\n",
+    "        \"min_uncertainty\": float(np.min(uncertainty_history)),\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c896a561",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Main simulation\n",
+    "def simulate_1d_quantum_scattering(\n",
+    "    hbar=1.0,\n",
+    "    mass=1.0,\n",
+    "    grid_size=2048,\n",
+    "    x_min=-100.0,\n",
+    "    x_max=100.0,\n",
+    "    dt=0.05,\n",
+    "    steps=900,\n",
+    "    save_every=90,\n",
+    "    barrier_height=1.6,\n",
+    "    barrier_width=2.2,\n",
+    "    x0=-35.0,\n",
+    "    sigma=3.5,\n",
+    "    k0=1.6,\n",
+    "    barrier_region=6.0,\n",
+    "):\n",
+    "    _validate_simulation_params(\n",
+    "        hbar,\n",
+    "        mass,\n",
+    "        grid_size,\n",
+    "        x_min,\n",
+    "        x_max,\n",
+    "        dt,\n",
+    "        steps,\n",
+    "        save_every,\n",
+    "        sigma,\n",
+    "        barrier_width,\n",
+    "        barrier_region,\n",
+    "    )\n",
+    "    x, dx, k, V, psi, phase_v_half, phase_t = _initialize_system(\n",
+    "        hbar, mass, grid_size, x_min, x_max, dt, barrier_height, barrier_width, x0, sigma, k0\n",
+    "    )\n",
+    "\n",
+    "    snapshots = []\n",
+    "    times = []\n",
+    "    norm_history = []\n",
+    "    x_mean_history = []\n",
+    "    p_mean_history = []\n",
+    "    uncertainty_history = []\n",
+    "\n",
+    "    for n in range(steps + 1):\n",
+    "        if n % save_every == 0:\n",
+    "            density, norm, x_mean, p_mean, uncertainty = _record_observables(psi, x, dx, k, hbar)\n",
+    "            snapshots.append(density.copy())\n",
+    "            times.append(n * dt)\n",
+    "            norm_history.append(norm)\n",
+    "            x_mean_history.append(x_mean)\n",
+    "            p_mean_history.append(p_mean)\n",
+    "            uncertainty_history.append(uncertainty)\n",
+    "\n",
+    "        psi = split_operator_step(psi, phase_v_half, phase_t)\n",
+    "\n",
+    "    final_density = np.abs(psi) ** 2\n",
+    "    diagnostics = _compute_diagnostics(final_density, x, dx, barrier_region, uncertainty_history)\n",
+    "\n",
+    "    return {\n",
+    "        \"x\": x,\n",
+    "        \"V\": V,\n",
+    "        \"snapshots\": snapshots,\n",
+    "        \"times\": times,\n",
+    "        \"norm_history\": norm_history,\n",
+    "        \"x_mean_history\": x_mean_history,\n",
+    "        \"p_mean_history\": p_mean_history,\n",
+    "        \"uncertainty_history\": uncertainty_history,\n",
+    "        \"diagnostics\": diagnostics,\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c97768b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot helpers\n",
+    "def _plot_density_panel(ax, x, snapshots, times, V):\n",
+    "    for density, t in zip(snapshots, times):\n",
+    "        ax.plot(x, density, label=f\"t={t:.1f}\")\n",
+    "    vmax = np.max(V)\n",
+    "    if vmax > 0:\n",
+    "        scale = np.max(snapshots[0]) / vmax\n",
+    "        ax.plot(x, V * scale, \"--\", linewidth=2, label=\"Barrier (scaled)\")\n",
+    "    ax.set_title(\"1D Quantum Wave Packet Scattering\")\n",
+    "    ax.set_xlabel(\"x\")\n",
+    "    ax.set_ylabel(r\"Probability density $|\\psi|^2$\")\n",
+    "    ax.legend()\n",
+    "    ax.grid(alpha=0.25)\n",
+    "\n",
+    "\n",
+    "def _plot_norm_panel(ax, times, norm_history):\n",
+    "    ax.plot(times, norm_history, marker=\"o\")\n",
+    "    ax.set_title(\"Normalization Conservation Check\")\n",
+    "    ax.set_xlabel(\"time\")\n",
+    "    ax.set_ylabel(\"Integral |psi|^2 dx\")\n",
+    "    ax.grid(alpha=0.25)\n",
+    "\n",
+    "\n",
+    "def _plot_expectation_panel(ax, times, x_mean_history, p_mean_history):\n",
+    "    ax.plot(times, x_mean_history, marker=\"o\", label=\"<x>\")\n",
+    "    ax.plot(times, p_mean_history, marker=\"s\", label=\"<p>\")\n",
+    "    ax.set_title(\"Expectation Values Over Time\")\n",
+    "    ax.set_xlabel(\"time\")\n",
+    "    ax.set_ylabel(\"value\")\n",
+    "    ax.legend()\n",
+    "    ax.grid(alpha=0.25)\n",
+    "\n",
+    "\n",
+    "def _plot_uncertainty_panel(ax, times, uncertainty_history, hbar):\n",
+    "    ax.plot(times, uncertainty_history, marker=\"^\", label=\"DxDp\")\n",
+    "    ax.axhline(0.5 * hbar, linestyle=\"--\", color=\"red\", label=\"hbar/2\")\n",
+    "    ax.set_title(\"Uncertainty Principle Check\")\n",
+    "    ax.set_xlabel(\"time\")\n",
+    "    ax.set_ylabel(\"DxDp\")\n",
+    "    ax.legend()\n",
+    "    ax.grid(alpha=0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e71e915",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_density_3d(result):\n",
+    "    x = result[\"x\"]\n",
+    "    times = np.array(result[\"times\"])\n",
+    "    snapshots = np.array(result[\"snapshots\"])\n",
+    "\n",
+    "    X, T = np.meshgrid(x, times)\n",
+    "    fig = plt.figure(figsize=(10, 6))\n",
+    "    ax = fig.add_subplot(111, projection=\"3d\")\n",
+    "    ax.plot_surface(X, T, snapshots, cmap=\"viridis\", linewidth=0, antialiased=True)\n",
+    "    ax.set_title(\"Probability Density Surface\")\n",
+    "    ax.set_xlabel(\"x\")\n",
+    "    ax.set_ylabel(\"time\")\n",
+    "    ax.set_zlabel(r\"$|\\psi|^2$\")\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fba6b3b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot entrypoint\n",
+    "def plot_results(result, hbar=1.0):\n",
+    "    x = result[\"x\"]\n",
+    "    V = result[\"V\"]\n",
+    "    snapshots = result[\"snapshots\"]\n",
+    "    times = result[\"times\"]\n",
+    "    norm_history = result[\"norm_history\"]\n",
+    "    x_mean_history = result[\"x_mean_history\"]\n",
+    "    p_mean_history = result[\"p_mean_history\"]\n",
+    "    uncertainty_history = result[\"uncertainty_history\"]\n",
+    "    fig, axes = plt.subplots(4, 1, figsize=(10, 14), sharex=False)\n",
+    "\n",
+    "    _plot_density_panel(axes[0], x, snapshots, times, V)\n",
+    "    _plot_norm_panel(axes[1], times, norm_history)\n",
+    "    _plot_expectation_panel(axes[2], times, x_mean_history, p_mean_history)\n",
+    "    _plot_uncertainty_panel(axes[3], times, uncertainty_history, hbar)\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "    plot_density_3d(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3fe0dff8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def validate_diagnostics(diagnostics, hbar=1.0, tol=1e-3):\n",
+    "    \"\"\"Return validation checks for core physical constraints.\"\"\"\n",
+    "    uncertainty_bound = 0.5 * hbar\n",
+    "    reflection = diagnostics[\"reflection\"]\n",
+    "    transmission = diagnostics[\"transmission\"]\n",
+    "    near_barrier = diagnostics[\"near_barrier\"]\n",
+    "    finite_values = np.all(\n",
+    "        np.isfinite(\n",
+    "            [\n",
+    "                diagnostics[\"final_norm\"],\n",
+    "                reflection,\n",
+    "                transmission,\n",
+    "                near_barrier,\n",
+    "                diagnostics[\"probability_sum\"],\n",
+    "                diagnostics[\"min_uncertainty\"],\n",
+    "                uncertainty_bound,\n",
+    "            ]\n",
+    "        )\n",
+    "    )\n",
+    "    checks = {\n",
+    "        \"diagnostics_finite\": bool(finite_values),\n",
+    "        \"norm_close_to_one\": bool(abs(diagnostics[\"final_norm\"] - 1.0) <= tol),\n",
+    "        \"probability_conserved\": bool(abs(diagnostics[\"probability_sum\"] - 1.0) <= tol),\n",
+    "        \"probability_terms_nonnegative\": bool(\n",
+    "            reflection >= -tol and transmission >= -tol and near_barrier >= -tol\n",
+    "        ),\n",
+    "        \"probability_terms_le_one\": bool(\n",
+    "            reflection <= 1.0 + tol\n",
+    "            and transmission <= 1.0 + tol\n",
+    "            and near_barrier <= 1.0 + tol\n",
+    "        ),\n",
+    "        \"uncertainty_respected\": bool(diagnostics[\"min_uncertainty\"] + tol >= uncertainty_bound),\n",
+    "    }\n",
+    "    checks[\"all_passed\"] = all(checks.values())\n",
+    "    return checks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b574c28",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def main():\n",
+    "    hbar = 1.0\n",
+    "    result = simulate_1d_quantum_scattering(hbar=hbar)\n",
+    "    diag = result[\"diagnostics\"]\n",
+    "    checks = validate_diagnostics(diag, hbar=hbar)\n",
+    "\n",
+    "    print(f\"Final normalization (should be ~1): {diag['final_norm']:.6f}\")\n",
+    "    print(f\"Reflection probability    : {diag['reflection']:.6f}\")\n",
+    "    print(f\"Transmission probability  : {diag['transmission']:.6f}\")\n",
+    "    print(f\"Near-barrier probability  : {diag['near_barrier']:.6f}\")\n",
+    "    print(f\"R + T + Near-barrier      : {diag['probability_sum']:.6f}\")\n",
+    "    print(\n",
+    "        \"Min uncertainty DxDp      : \"\n",
+    "        f\"{diag['min_uncertainty']:.6f} (>= {0.5 * hbar:.3f})\"\n",
+    "    )\n",
+    "    print(f\"Validation all passed      : {checks['all_passed']}\")\n",
+    "\n",
+    "    for name, passed in checks.items():\n",
+    "        if name == \"all_passed\":\n",
+    "            continue\n",
+    "        print(f\"  - {name:25}: {passed}\")\n",
+    "\n",
+    "    plot_results(result, hbar=hbar)\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}