From 06990f3af4775cd12ae1bfd3eb8c3f88997c6ca5 Mon Sep 17 00:00:00 2001
From: Wuyang Ren <waynrn@outlook.com>
Date: Sun, 23 Nov 2025 01:14:41 -0800
Subject: [PATCH 1/4] Asset pricing notebook

---
 notebooks/asset_pricing_python.ipynb | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 notebooks/asset_pricing_python.ipynb

diff --git a/notebooks/asset_pricing_python.ipynb b/notebooks/asset_pricing_python.ipynb
new file mode 100644
index 0000000..e69de29

From cdd743cc95720907bb2fd2a68c501f580712c981 Mon Sep 17 00:00:00 2001
From: Wuyang Ren <waynrn@outlook.com>
Date: Sun, 23 Nov 2025 01:18:44 -0800
Subject: [PATCH 2/4] Asset pricing notebook

---
 notebooks/asset_pricing_python.ipynb | 324 +++++++++++++++++++++++++++
 1 file changed, 324 insertions(+)

diff --git a/notebooks/asset_pricing_python.ipynb b/notebooks/asset_pricing_python.ipynb
index e69de29..0cbedd7 100644
--- a/notebooks/asset_pricing_python.ipynb
+++ b/notebooks/asset_pricing_python.ipynb
@@ -0,0 +1,324 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "64129d57",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax\n",
+    "import jax.numpy as jnp\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.integrate import quad\n",
+    "from functools import partial\n",
+    "import numpy as np\n",
+    "import pyomo.environ as pyo\n",
+    "from pyomo.opt import TerminationCondition"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eba46715",
+   "metadata": {},
+   "source": [
+    "[FORMULA PLACEHOLDER]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "738464bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def matern_kernel_0p5(t_i, t_j, sigma, rho):\n",
+    "    d = jnp.abs(t_i - t_j)\n",
+    "    return sigma**2 * jnp.exp(-d / rho)\n",
+    "\n",
+    "def integrated_matern_kernel_0p5(t_i, t_j, sigma, rho):\n",
+    "    s = t_i - t_j\n",
+    "    d = jnp.abs(s)\n",
+    "\n",
+    "    def if_s_neg():\n",
+    "        return rho * (sigma**2) * (jnp.exp(-d / rho) - jnp.exp(-t_j / rho))\n",
+    "\n",
+    "    def if_s_non_neg():\n",
+    "        return rho * (sigma**2) * (2 - jnp.exp(-d / rho) - jnp.exp(-t_j / rho))\n",
+    "\n",
+    "    return jax.lax.cond(s < 0, if_s_neg, if_s_non_neg)\n",
+    "\n",
+    "@partial(jax.jit, static_argnums=(2,))\n",
+    "def integrated_matern_kernel_matrices(t_i, t_j, nu, sigma, rho):\n",
+    "    K = jax.vmap(\n",
+    "        jax.vmap(matern_kernel_0p5, in_axes=(None, 0, None, None)),\n",
+    "        in_axes=(0, None, None, None),)(t_i, t_j, sigma, rho)\n",
+    "    K_tilde = jax.vmap(\n",
+    "        jax.vmap(integrated_matern_kernel_0p5, in_axes=(None, 0, None, None)),\n",
+    "        in_axes=(0, None, None, None),)(t_i, t_j, sigma, rho)\n",
+    "    return K, K_tilde\n",
+    "    \n",
+    "#The function is defined in asset_pricing_benchmark.py\n",
+    "def mu_f_array(t, c, g, r, x_0):\n",
+    "\n",
+    "    def x(s, c, g, x_0):\n",
+    "        return (x_0 + (c / g)) * jnp.exp(g * s) - (c / g)\n",
+    "\n",
+    "    def discount_x(s):\n",
+    "        return jnp.exp(-r * s) * x(s, c, g, x_0)\n",
+    "\n",
+    "    result = jnp.zeros_like(t)\n",
+    "    for i, t_value in enumerate(t):\n",
+    "        integral, err = quad(discount_x, t_value, 2000)\n",
+    "        result = result.at[i].set(jnp.exp(r * t_value) * integral)\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d6204be",
+   "metadata": {},
+   "source": [
+    "Setting up the parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "506ce9b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = 0.1\n",
+    "c = 0.02\n",
+    "g = -0.2\n",
+    "x_0 = 0.01\n",
+    "nu = 0.5\n",
+    "sigma = 1.0\n",
+    "rho = 10\n",
+    "solver_type = \"ipopt\"\n",
+    "train_T = 40.0\n",
+    "train_points = 41\n",
+    "test_T = 50.0\n",
+    "test_points = 100\n",
+    "train_points_list = None\n",
+    "verbose = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af2e1dff",
+   "metadata": {},
+   "source": [
+    "Traning/testing grids and kernel matrices. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6abe44d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if passing in `train_points` then doesn't us a grid.  Otherwise, uses linspace\n",
+    "if train_points_list is None:\n",
+    "    train_data = jnp.linspace(0, train_T, train_points)\n",
+    "else:\n",
+    "    train_data = jnp.array(train_points_list)\n",
+    "test_data = jnp.linspace(0, test_T, test_points)\n",
+    "\n",
+    "# Construct kernel matrices\n",
+    "N = len(train_data)\n",
+    "K, K_tilde = integrated_matern_kernel_matrices(\n",
+    "    train_data, train_data, nu, sigma, rho\n",
+    ")\n",
+    "K = np.array(K)  # pyomo doesn't support jax arrays\n",
+    "K_tilde = np.array(K_tilde)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbfbadc3",
+   "metadata": {},
+   "source": [
+    "Setting up the Pyomo model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ddd272e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create pyomo model and variables\n",
+    "m = pyo.ConcreteModel()\n",
+    "m.I = range(N)\n",
+    "m.alpha_mu = pyo.Var(m.I, within=pyo.Reals, initialize=0.0)\n",
+    "m.mu_0 = pyo.Var(within=pyo.NonNegativeReals, initialize=0.0)\n",
+    "\n",
+    "# Map kernels to variables. Pyomo doesn't support p_0 + K_tilde @ m.alpha\n",
+    "def mu(m, i):\n",
+    "    return m.mu_0 + sum(K_tilde[i, j] * m.alpha_mu[j] for j in m.I)\n",
+    "\n",
+    "def dmu_dt(m, i):\n",
+    "    return sum(K[i, j] * m.alpha_mu[j] for j in m.I)\n",
+    "\n",
+    "def x(i):\n",
+    "    return (x_0 + (c / g)) * np.exp(g * i) - (c / g)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0ef8a00",
+   "metadata": {},
+   "source": [
+    "Solving the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "668cf5ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define constraints and objective for model and solve\n",
+    "@m.Constraint(m.I)\n",
+    "def dp_dt_constraint(m, i):\n",
+    "    return dmu_dt(m, i) == r * mu(m, i) - x(i)\n",
+    "\n",
+    "@m.Objective(sense=pyo.minimize)\n",
+    "def min_norm(m):  # alpha @ K @ alpha not supported by pyomo\n",
+    "    return sum(K[i, j] * m.alpha_mu[i] * m.alpha_mu[j] for i in m.I for j in m.I)\n",
+    "\n",
+    "solver = pyo.SolverFactory(solver_type)\n",
+    "options = {\n",
+    "    \"tol\": 1e-14,  # Tighten the tolerance for optimality\n",
+    "    \"dual_inf_tol\": 1e-14,  # Tighten the dual infeasibility tolerance\n",
+    "    \"constr_viol_tol\": 1e-14,  # Tighten the constraint violation tolerance\n",
+    "    \"max_iter\": 5000,  # Adjust the maximum number of iterations if needed\n",
+    "}\n",
+    "results = solver.solve(m, tee=verbose, options=options)\n",
+    "if not results.solver.termination_condition == TerminationCondition.optimal:\n",
+    "    print(str(results.solver))  # raise exception?\n",
+    "\n",
+    "alpha_mu = jnp.array([pyo.value(m.alpha_mu[i]) for i in m.I])\n",
+    "mu_0 = pyo.value(m.mu_0)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb1272a7",
+   "metadata": {},
+   "source": [
+    "Building the JAX interpolator and evaluating on the test grid."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "82b7897f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "solve_time(s) = 0.050354957580566406, E(|rel_error(p)|) = 0.00015457985864486545\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Interpolator using training data\n",
+    "@jax.jit\n",
+    "def kernel_solution(test_data):\n",
+    "    # pointwise comparison test_data to train_data\n",
+    "    K_test, K_tilde_test = integrated_matern_kernel_matrices(\n",
+    "        test_data, train_data, nu, sigma, rho\n",
+    "    )\n",
+    "    mu_test = mu_0 + K_tilde_test @ alpha_mu\n",
+    "    return mu_test\n",
+    "\n",
+    "mu_benchmark = mu_f_array(test_data, c, g, r, x_0)\n",
+    "mu_test = kernel_solution(test_data)\n",
+    "\n",
+    "mu_rel_error = jnp.abs(mu_benchmark - mu_test) / mu_benchmark\n",
+    "print(\n",
+    "    f\"solve_time(s) = {results.solver.Time}, E(|rel_error(p)|) = {mu_rel_error.mean()}\"\n",
+    ")\n",
+    "\n",
+    "results_dict = {\n",
+    "    \"t_train\": train_data,\n",
+    "    \"t_test\": test_data,\n",
+    "    \"p_test\": mu_test,\n",
+    "    \"p_benchmark\": mu_benchmark,\n",
+    "    \"p_rel_error\": mu_rel_error,\n",
+    "    \"alpha\": alpha_mu,\n",
+    "    \"p_0\": mu_0,\n",
+    "    \"solve_time\": results.solver.Time,\n",
+    "    \"kernel_solution\": kernel_solution,  # interpolator\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "cdcd3e37",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x350 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3.5), constrained_layout=True)\n",
+    "\n",
+    "T = float(train_data.max())\n",
+    "\n",
+    "ax1.plot(test_data, mu_test, label=\"Kernel Approximation\")\n",
+    "ax1.plot(test_data, mu_benchmark, linestyle=\"--\", label=\"Closed-Form Solution\")\n",
+    "ax1.axvline(T, linestyle=\":\", color=\"black\", label=\"Extrapolation/Interpolation\")\n",
+    "ax1.set_xlabel(\"Time\")\n",
+    "ax1.set_ylabel(\"Price\")\n",
+    "ax1.legend(loc=\"lower right\")\n",
+    "\n",
+    "ax2.plot(test_data, mu_rel_error, label=\"Relative error\")\n",
+    "ax2.axvline(T, linestyle=\":\", color=\"black\", label=\"Extrapolation/Interpolation\")\n",
+    "ax2.set_xlabel(\"Time\")\n",
+    "ax2.set_yscale(\"log\")\n",
+    "ax2.legend(loc=\"upper left\")\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "kernel-econ-alignment (3.13.5)",
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 4c1a3d0128aff2ea12d8f81f540fcad934a64fff Mon Sep 17 00:00:00 2001
From: Wuyang Ren <waynrn@outlook.com>
Date: Tue, 25 Nov 2025 00:49:13 -0800
Subject: [PATCH 3/4] added neoclassical growth notebook

---
 notebooks/neoclassical_growth_python.ipynb | 413 +++++++++++++++++++++
 1 file changed, 413 insertions(+)
 create mode 100644 notebooks/neoclassical_growth_python.ipynb

diff --git a/notebooks/neoclassical_growth_python.ipynb b/notebooks/neoclassical_growth_python.ipynb
new file mode 100644
index 0000000..b3f73dd
--- /dev/null
+++ b/notebooks/neoclassical_growth_python.ipynb
@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "5c73eef8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax\n",
+    "import jax.numpy as jnp\n",
+    "import numpy as np\n",
+    "from scipy.integrate import solve_bvp\n",
+    "from functools import partial\n",
+    "import pyomo.environ as pyo\n",
+    "from pyomo.opt import TerminationCondition\n",
+    "import matplotlib.pyplot as plt\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04bae11a",
+   "metadata": {},
+   "source": [
+    "[FORMULA PLACEHOLDER]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "0f9b17b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def matern_kernel_0p5(t_i, t_j, sigma, rho):\n",
+    "    d = jnp.abs(t_i - t_j)\n",
+    "    return sigma**2 * jnp.exp(-d / rho)\n",
+    "\n",
+    "def integrated_matern_kernel_0p5(t_i, t_j, sigma, rho):\n",
+    "    s = t_i - t_j\n",
+    "    d = jnp.abs(s)\n",
+    "\n",
+    "    def if_s_neg():\n",
+    "        return rho * (sigma**2) * (jnp.exp(-d / rho) - jnp.exp(-t_j / rho))\n",
+    "\n",
+    "    def if_s_non_neg():\n",
+    "        return rho * (sigma**2) * (2 - jnp.exp(-d / rho) - jnp.exp(-t_j / rho))\n",
+    "\n",
+    "    return jax.lax.cond(s < 0, if_s_neg, if_s_non_neg)\n",
+    "\n",
+    "@partial(jax.jit, static_argnums=(2,))\n",
+    "def integrated_matern_kernel_matrices(t_i, t_j, nu, sigma, rho):\n",
+    "    K = jax.vmap(\n",
+    "        jax.vmap(matern_kernel_0p5, in_axes=(None, 0, None, None)),\n",
+    "        in_axes=(0, None, None, None),)(t_i, t_j, sigma, rho)\n",
+    "    K_tilde = jax.vmap(\n",
+    "        jax.vmap(integrated_matern_kernel_0p5, in_axes=(None, 0, None, None)),\n",
+    "        in_axes=(0, None, None, None),)(t_i, t_j, sigma, rho)\n",
+    "    return K, K_tilde\n",
+    "\n",
+    "# Neoclassical Growth Benchmark solution: the function is defined in neoclassical_growth_benchmark.py\n",
+    "def neoclassical_growth_benchmark(a, delta, r, sigma_crra, k_0, t_grid, perturb_k=1e-4):\n",
+    "    #a: capital share\n",
+    "    #delta: depreciation \n",
+    "    #r: discount rate\n",
+    "    #sigma_crra: the constant relative risk aversion coefficient\n",
+    "    #k_0: initial condition for capital\n",
+    "    #t_grid: The grid for time where we want to solve the problem over (0,t_1,...,T)\n",
+    "    #perturb_k : how far away from the steady-state capital you want the trajectory be at the terminal time, T\n",
+    "\n",
+    "    k_ss = ((delta + r) / a) ** (1 / (a - 1))\n",
+    "    c_ss = a * k_ss**a - -delta * k_ss\n",
+    "    # perturb the final value of the capital at T to help convergence\n",
+    "    k_T = k_ss - perturb_k\n",
+    "\n",
+    "    def ODE(t, y):\n",
+    "        k = y[0]\n",
+    "        c = y[1]\n",
+    "        return jnp.vstack(\n",
+    "            (\n",
+    "                k**a - c - delta * k,\n",
+    "                (c / sigma_crra) * (a * k ** (a - 1) - r - delta),\n",
+    "            )\n",
+    "        )\n",
+    "\n",
+    "    def bc(ya, yb):\n",
+    "        return jnp.array([ya[0] - k_0, yb[0] - k_T]) #boundary condition, k(0) = k_0, k(T) = k_T\n",
+    "\n",
+    "    iv = 1 * jnp.ones((2, t_grid.size))\n",
+    "    solution = solve_bvp(ODE, bc, t_grid, iv)\n",
+    "\n",
+    "    # the \"solution\" is an interpolator already, can just unpack\n",
+    "    T_max = t_grid[-1]\n",
+    "\n",
+    "    def interpolate_solution(t_grid):\n",
+    "        if t_grid[-1] > T_max:\n",
+    "            raise ValueError(\"Extrapolation not supported\")\n",
+    "        val = solution.sol(t_grid)\n",
+    "        return val[0], val[1]\n",
+    "\n",
+    "    return interpolate_solution"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4b3a7c1",
+   "metadata": {},
+   "source": [
+    "Setting up the parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "c952a1ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 1 / 3\n",
+    "delta = 0.1\n",
+    "rho_hat = 0.11\n",
+    "k_0 = 1.0 #k_0 is the state variable initial conditions here, i.e., x_0\n",
+    "nu = 0.5\n",
+    "sigma = 1.0\n",
+    "rho = 10\n",
+    "solver_type = \"ipopt\"\n",
+    "train_T = 40.0\n",
+    "train_points = 41\n",
+    "test_T = 50\n",
+    "test_points = 100\n",
+    "benchmark_T = 60.0\n",
+    "benchmark_points = 300\n",
+    "train_points_list = None\n",
+    "lambda_p = 0.0 #Smooting penalty for the optimizer, This is purely because of the DAE term mu*c = 1\n",
+    "verbose = False\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8b86a1b",
+   "metadata": {},
+   "source": [
+    "Traning/testing grids and kernel matrices. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "5b032c8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if passing in `train_points` then doesn't us a grid.  Otherwise, uses linspace\n",
+    "if train_points_list is None:\n",
+    "    train_data = jnp.linspace(0, train_T, train_points)\n",
+    "else:\n",
+    "    train_data = jnp.array(train_points_list)\n",
+    "test_data = jnp.linspace(0, test_T, test_points)\n",
+    "benchmark_grid = jnp.linspace(0, benchmark_T, benchmark_points)\n",
+    "\n",
+    "# Construct kernel matrices\n",
+    "N = len(train_data)\n",
+    "K, K_tilde = integrated_matern_kernel_matrices(\n",
+    "    train_data, train_data, nu, sigma, rho\n",
+    ")\n",
+    "K = np.array(K)  # pyomo doesn't support jax arrays\n",
+    "K_tilde = np.array(K_tilde)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "024a4509",
+   "metadata": {},
+   "source": [
+    "Setting up the Pyomo model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "6ae35fc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create pyomo model and variables\n",
+    "m = pyo.ConcreteModel()\n",
+    "m.I = range(N)\n",
+    "m.alpha_mu = pyo.Var(m.I, within=pyo.Reals, initialize=0.0)\n",
+    "m.alpha_c = pyo.Var(m.I, within=pyo.Reals, initialize=0.0)\n",
+    "m.alpha_k = pyo.Var(m.I, within=pyo.Reals, initialize=0.0) #k is the state variable here, i.e., x\n",
+    "m.c_0 = pyo.Var(within=pyo.NonNegativeReals, initialize=k_0**a - delta * k_0)\n",
+    "m.mu_0 = pyo.Var(within=pyo.NonNegativeReals, initialize=k_0**a - delta * k_0)\n",
+    "\n",
+    "# Map kernels to variables. Pyomo doesn't support c_0 + K_tilde @ m.alpha_c\n",
+    "def mu(m, i):\n",
+    "    return m.mu_0 + sum(K_tilde[i, j] * m.alpha_mu[j] for j in m.I)\n",
+    "\n",
+    "def c(m, i):\n",
+    "    return m.c_0 + sum(K_tilde[i, j] * m.alpha_c[j] for j in m.I)\n",
+    "\n",
+    "def k(m, i): #k is the state variable here, i.e., x\n",
+    "    return k_0 + sum(K_tilde[i, j] * m.alpha_k[j] for j in m.I)\n",
+    "\n",
+    "def dmu_dt(m, i):\n",
+    "    return sum(K[i, j] * m.alpha_mu[j] for j in m.I)\n",
+    "\n",
+    "def dk_dt(m, i): #dk_dt is the state variable's derivative here, i.e., dx_dt\n",
+    "    return sum(K[i, j] * m.alpha_k[j] for j in m.I)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6db130ab",
+   "metadata": {},
+   "source": [
+    "Solving the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "f3766fd5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define constraints and objective for model and solve\n",
+    "@m.Constraint(m.I)  # for each index in m.I\n",
+    "def resource_constraint(m, i):\n",
+    "    return dk_dt(m, i) == k(m, i) ** a - delta * k(m, i) - c(m, i)\n",
+    "\n",
+    "@m.Constraint(m.I)  # for each index in m.I\n",
+    "def euler(m, i):\n",
+    "    return dmu_dt(m, i) == -mu(m, i) * (a * k(m, i) ** (a - 1) - delta - rho_hat)\n",
+    "\n",
+    "@m.Constraint(m.I)  # for each index in m.I\n",
+    "def shadow_price(m, i):\n",
+    "    return mu(m, i) * c(m, i) == 1.0\n",
+    "\n",
+    "\n",
+    "@m.Objective(sense=pyo.minimize)\n",
+    "def min_norm(m):  # alpha @ K @ alpha not supported by pyomo\n",
+    "    return sum(K[i, j] * m.alpha_mu[i] * m.alpha_mu[j] for i in m.I for j in m.I)+sum(K[i, j] * m.alpha_k[i] * m.alpha_k[j] for i in m.I for j in m.I) + lambda_p*(sum(K[i, j] * m.alpha_c[i] * m.alpha_c[j] for i in m.I for j in m.I)\n",
+    "    + sum(K[i, j] * m.alpha_k[i] * m.alpha_k[j] for i in m.I for j in m.I)+ sum(K[i, j] * m.alpha_mu[i] * m.alpha_mu[j] for i in m.I for j in m.I)\n",
+    "    )\n",
+    "    #lambda_p makes sure the optimizer returns smooth (non-wiggly solutions in the extrapolation), we set it to zero\n",
+    "solver = pyo.SolverFactory(solver_type)\n",
+    "options = {\n",
+    "    \"tol\": 1e-8,  # Tighten the tolerance for optimality\n",
+    "    \"dual_inf_tol\": 1e-8,  # Tighten the dual infeasibility tolerance\n",
+    "    \"constr_viol_tol\": 1e-8,  # Tighten the constraint violation tolerance\n",
+    "    \"max_iter\": 2000,  # Adjust the maximum number of iterations if needed\n",
+    "}  # See https://coin-or.github.io/Ipopt/OPTIONS.html for more details # can add options here.   See https://coin-or.github.io/Ipopt/OPTIONS.html#OPTIONS_AMPL\n",
+    "results = solver.solve(m, tee=verbose, options=options)\n",
+    "if not results.solver.termination_condition == TerminationCondition.optimal:\n",
+    "    print(str(results.solver))  # raise exception?\n",
+    "\n",
+    "alpha_c = jnp.array([pyo.value(m.alpha_c[i]) for i in m.I])\n",
+    "alpha_k = jnp.array([pyo.value(m.alpha_k[i]) for i in m.I])\n",
+    "c_0 = pyo.value(m.c_0)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55689253",
+   "metadata": {},
+   "source": [
+    "Building the JAX interpolator and evaluating on the test grid."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "b28701b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "solve_time(s) = 0.041794776916503906, E(|rel_error(k)|) = 0.00036802463000640273, E(|rel_error(c)|) = 0.0006670550792478025\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Interpolator using training data\n",
+    "@jax.jit\n",
+    "def kernel_solution(test_data):\n",
+    "    # pointwise comparison test_data to train_data\n",
+    "    K_test, K_tilde_test = integrated_matern_kernel_matrices(\n",
+    "        test_data, train_data, nu, sigma, rho\n",
+    "    )\n",
+    "    c_test = c_0 + K_tilde_test @ alpha_c\n",
+    "    k_test = k_0 + K_tilde_test @ alpha_k\n",
+    "    return k_test, c_test\n",
+    "\n",
+    "sol_benchmark = neoclassical_growth_benchmark(\n",
+    "    a, delta, rho_hat, 1.0, k_0, benchmark_grid\n",
+    ")\n",
+    "\n",
+    "# Generate test_data and compare to the benchmark\n",
+    "k_benchmark, c_benchmark = sol_benchmark(test_data)\n",
+    "k_test, c_test = kernel_solution(test_data)\n",
+    "\n",
+    "k_rel_error = jnp.abs(k_benchmark - k_test) / k_benchmark\n",
+    "c_rel_error = jnp.abs(c_benchmark - c_test) / c_benchmark\n",
+    "print(\n",
+    "    f\"solve_time(s) = {results.solver.Time}, E(|rel_error(k)|) = {k_rel_error.mean()}, E(|rel_error(c)|) = {c_rel_error.mean()}\"\n",
+    ")\n",
+    "\n",
+    "results_dict = {\n",
+    "    \"t_train\": train_data,\n",
+    "    \"t_test\": test_data,\n",
+    "    \"k_test\": k_test,\n",
+    "    \"c_test\": c_test,\n",
+    "    \"k_benchmark\": k_benchmark,\n",
+    "    \"c_benchmark\": c_benchmark,\n",
+    "    \"k_rel_error\": k_rel_error,\n",
+    "    \"c_rel_error\": c_rel_error,\n",
+    "    \"alpha_c\": alpha_c,\n",
+    "    \"alpha_k\": alpha_k,\n",
+    "    \"c_0\": c_0,\n",
+    "    \"solve_time\": results.solver.Time,\n",
+    "    \"kernel_solution\": kernel_solution,  # interpolator\n",
+    "    \"benchmark_solution\": sol_benchmark,  # interpolator\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "f0d08587",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x11984d450>"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x700 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 2, figsize=(10, 7))\n",
+    "(ax1, ax2), (ax3, ax4) = axes\n",
+    "\n",
+    "T = float(train_data.max())\n",
+    "\n",
+    "ax1.plot(test_data, k_test, label=\"Kernel Approximation\")\n",
+    "ax1.plot(test_data, k_benchmark, linestyle=\"--\", label=\"Closed-Form Solution\")\n",
+    "ax1.axvline(T, linestyle=\":\", color=\"black\", label=\"Extrapolation/Interpolation\")\n",
+    "ax1.set_xlabel(\"Time\")\n",
+    "ax1.set_ylabel(\"Capital\")\n",
+    "ax1.legend(loc=\"lower right\")\n",
+    "\n",
+    "ax2.plot(test_data, k_rel_error, label=\"Relative error for k(t)\")\n",
+    "ax2.axvline(T, linestyle=\":\", color=\"black\", label=\"Extrapolation/Interpolation\")\n",
+    "ax2.set_xlabel(\"Time\")\n",
+    "ax2.set_yscale(\"log\")\n",
+    "ax2.legend(loc=\"lower left\")\n",
+    "\n",
+    "ax3.plot(test_data, c_test, label=\"Kernel Approximation\")\n",
+    "ax3.plot(test_data, c_benchmark, linestyle=\"--\", label=\"Closed-Form Solution\")\n",
+    "ax3.axvline(T, linestyle=\":\", color=\"black\", label=\"Extrapolation/Interpolation\")\n",
+    "ax3.set_xlabel(\"Time\")\n",
+    "ax3.set_ylabel(\"Consumption\")\n",
+    "ax3.legend(loc=\"lower right\")\n",
+    "\n",
+    "ax4.plot(test_data, c_rel_error, label=\"Relative error for c(t)\")\n",
+    "ax4.axvline(T, linestyle=\":\", color=\"black\", label=\"Extrapolation/Interpolation\")\n",
+    "ax4.set_xlabel(\"Time\")\n",
+    "ax4.set_yscale(\"log\")\n",
+    "ax4.legend(loc=\"lower left\")\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "kernel-econ-alignment (3.13.5)",
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From e1c26b5891b5b4058589885aaae64088b20caa79 Mon Sep 17 00:00:00 2001
From: Wuyang Ren <waynrn@outlook.com>
Date: Tue, 25 Nov 2025 15:00:13 -0800
Subject: [PATCH 4/4] Removed nu arguments in integrated matern kernel matrices

---
 notebooks/asset_pricing_python.ipynb       | 13 ++++-----
 notebooks/neoclassical_growth_python.ipynb | 33 +++++++++++-----------
 2 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/notebooks/asset_pricing_python.ipynb b/notebooks/asset_pricing_python.ipynb
index 0cbedd7..2380057 100644
--- a/notebooks/asset_pricing_python.ipynb
+++ b/notebooks/asset_pricing_python.ipynb
@@ -49,7 +49,7 @@
     "    return jax.lax.cond(s < 0, if_s_neg, if_s_non_neg)\n",
     "\n",
     "@partial(jax.jit, static_argnums=(2,))\n",
-    "def integrated_matern_kernel_matrices(t_i, t_j, nu, sigma, rho):\n",
+    "def integrated_matern_kernel_matrices_0p5(t_i, t_j, sigma, rho):\n",
     "    K = jax.vmap(\n",
     "        jax.vmap(matern_kernel_0p5, in_axes=(None, 0, None, None)),\n",
     "        in_axes=(0, None, None, None),)(t_i, t_j, sigma, rho)\n",
@@ -93,7 +93,6 @@
     "c = 0.02\n",
     "g = -0.2\n",
     "x_0 = 0.01\n",
-    "nu = 0.5\n",
     "sigma = 1.0\n",
     "rho = 10\n",
     "solver_type = \"ipopt\"\n",
@@ -129,8 +128,8 @@
     "\n",
     "# Construct kernel matrices\n",
     "N = len(train_data)\n",
-    "K, K_tilde = integrated_matern_kernel_matrices(\n",
-    "    train_data, train_data, nu, sigma, rho\n",
+    "K, K_tilde = integrated_matern_kernel_matrices_0p5(\n",
+    "    train_data, train_data, sigma, rho\n",
     ")\n",
     "K = np.array(K)  # pyomo doesn't support jax arrays\n",
     "K_tilde = np.array(K_tilde)\n"
@@ -225,7 +224,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "solve_time(s) = 0.050354957580566406, E(|rel_error(p)|) = 0.00015457985864486545\n"
+      "solve_time(s) = 0.06695890426635742, E(|rel_error(p)|) = 0.00015457985864486545\n"
      ]
     }
    ],
@@ -234,8 +233,8 @@
     "@jax.jit\n",
     "def kernel_solution(test_data):\n",
     "    # pointwise comparison test_data to train_data\n",
-    "    K_test, K_tilde_test = integrated_matern_kernel_matrices(\n",
-    "        test_data, train_data, nu, sigma, rho\n",
+    "    K_test, K_tilde_test = integrated_matern_kernel_matrices_0p5(\n",
+    "        test_data, train_data, sigma, rho\n",
     "    )\n",
     "    mu_test = mu_0 + K_tilde_test @ alpha_mu\n",
     "    return mu_test\n",
diff --git a/notebooks/neoclassical_growth_python.ipynb b/notebooks/neoclassical_growth_python.ipynb
index b3f73dd..ebd9b45 100644
--- a/notebooks/neoclassical_growth_python.ipynb
+++ b/notebooks/neoclassical_growth_python.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 9,
    "id": "5c73eef8",
    "metadata": {},
    "outputs": [],
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 10,
    "id": "0f9b17b7",
    "metadata": {},
    "outputs": [],
@@ -49,7 +49,7 @@
     "    return jax.lax.cond(s < 0, if_s_neg, if_s_non_neg)\n",
     "\n",
     "@partial(jax.jit, static_argnums=(2,))\n",
-    "def integrated_matern_kernel_matrices(t_i, t_j, nu, sigma, rho):\n",
+    "def integrated_matern_kernel_matrices_0p5(t_i, t_j, sigma, rho):\n",
     "    K = jax.vmap(\n",
     "        jax.vmap(matern_kernel_0p5, in_axes=(None, 0, None, None)),\n",
     "        in_axes=(0, None, None, None),)(t_i, t_j, sigma, rho)\n",
@@ -111,7 +111,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 11,
    "id": "c952a1ad",
    "metadata": {},
    "outputs": [],
@@ -120,7 +120,6 @@
     "delta = 0.1\n",
     "rho_hat = 0.11\n",
     "k_0 = 1.0 #k_0 is the state variable initial conditions here, i.e., x_0\n",
-    "nu = 0.5\n",
     "sigma = 1.0\n",
     "rho = 10\n",
     "solver_type = \"ipopt\"\n",
@@ -146,7 +145,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 12,
    "id": "5b032c8a",
    "metadata": {},
    "outputs": [],
@@ -161,8 +160,8 @@
     "\n",
     "# Construct kernel matrices\n",
     "N = len(train_data)\n",
-    "K, K_tilde = integrated_matern_kernel_matrices(\n",
-    "    train_data, train_data, nu, sigma, rho\n",
+    "K, K_tilde = integrated_matern_kernel_matrices_0p5(\n",
+    "    train_data, train_data, sigma, rho\n",
     ")\n",
     "K = np.array(K)  # pyomo doesn't support jax arrays\n",
     "K_tilde = np.array(K_tilde)\n",
@@ -179,7 +178,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 13,
    "id": "6ae35fc8",
    "metadata": {},
    "outputs": [],
@@ -220,7 +219,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 14,
    "id": "f3766fd5",
    "metadata": {},
    "outputs": [],
@@ -271,7 +270,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 15,
    "id": "b28701b9",
    "metadata": {},
    "outputs": [
@@ -279,7 +278,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "solve_time(s) = 0.041794776916503906, E(|rel_error(k)|) = 0.00036802463000640273, E(|rel_error(c)|) = 0.0006670550792478025\n"
+      "solve_time(s) = 0.21670770645141602, E(|rel_error(k)|) = 0.00036802463000640273, E(|rel_error(c)|) = 0.0006670550792478025\n"
      ]
     }
    ],
@@ -288,8 +287,8 @@
     "@jax.jit\n",
     "def kernel_solution(test_data):\n",
     "    # pointwise comparison test_data to train_data\n",
-    "    K_test, K_tilde_test = integrated_matern_kernel_matrices(\n",
-    "        test_data, train_data, nu, sigma, rho\n",
+    "    K_test, K_tilde_test = integrated_matern_kernel_matrices_0p5(\n",
+    "        test_data, train_data, sigma, rho\n",
     "    )\n",
     "    c_test = c_0 + K_tilde_test @ alpha_c\n",
     "    k_test = k_0 + K_tilde_test @ alpha_k\n",
@@ -329,17 +328,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 16,
    "id": "f0d08587",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x11984d450>"
+       "<matplotlib.legend.Legend at 0x1172287d0>"
       ]
      },
-     "execution_count": 52,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     },