delete irrelevant part

Author: HumphreyYang

lectures/calvo_gradient.md

@@ -1014,97 +1014,4 @@ After checking the above formulas, please implement them in Python and check tha
 
 After that, we can put this material into a second chapter of the Calvo gradient lecture. 
 
-I can write why we regard this as ML -- i.e., sort of brute force, but less brute force than than the earlier gradient method because here we recognize more about the mathematical structure of $V$.
-
-```{code-cell} ipython3
-import numpy as np
-import jax.numpy as jnp
-from jax import grad, jit
-import optax
-
-@jit
-def compute_V(μ, β, c, α=1, u0=1, u1=0.5, u2=3):
-    θ = compute_θ(μ, α)
-    
-    h0 = u0
-    h1 = -u1 * α
-    h2 = -0.5 * u2 * α**2
-    
-    T = len(μ) - 1
-    t = np.arange(T)
-    
-    # Compute sum except for the last element
-    V_sum = np.sum(β**t * (h0 + h1 * θ[:T] + h2 * θ[:T]**2 - 0.5 * c * μ[:T]**2))
-    
-    # Compute the final term
-    V_final = (β**T / (1 - β)) * (h0 + h1 * μ[-1] + h2 * μ[-1]**2 - 0.5 * c * μ[-1]**2)
-    
-    V = V_sum + V_final
-    
-    return V
-
-
-def compute_θ(μ, α=1):
-    λ = α / (1 + α)
-    T = len(μ) - 1
-    μbar = μ[-1]
-    
-    # Create an array of powers for λ
-    λ_powers = λ ** jnp.arange(T + 1)
-    
-    # Compute the weighted sums for all t
-    weighted_sums = jnp.array(
-        [jnp.sum(λ_powers[:T-t] * μ[t:T]) for t in range(T)])
-    
-    # Compute θ values except for the last element
-    θ = (1 - λ) * weighted_sums + λ**(T - jnp.arange(T)) * μbar
-    
-    # Set the last element
-    θ = jnp.append(θ, μbar)
-    
-    return θ
-
-def compute_J(μ, β, c, α=1, u0=1, u1=0.5, u2=3):
-    θ = compute_θ(μ, α)
-    T = len(μ)
-    
-    h0 = u0
-    h1 = -u1 * α
-    h2 = -0.5 * u2 * α**2
-    
-    λ = α / (1 + α)
-    A = jnp.eye(T, T) - λ * jnp.eye(T, T, k=1)
-    B = (1 - λ) * np.linalg.inv(A)
-
-    e_vec = jnp.hstack([jnp.ones(T-1), jnp.sqrt(1/(1-β))])
-    β_vec = jnp.hstack([jnp.array([β**(t/2) for t in range(T-1)]), jnp.sqrt(β**(T-1)/(1-β))])
-    
-    β_vec_sq = β_vec**2
-    f1 = (B * β_vec * e_vec)
-    
-    disc_B = β_vec * B
-    F1 = (disc_B).T @ (disc_B)
-    F2 = jnp.diag(β_vec_sq)
-    
-    g1 = h1 * f1
-    G2 = h2 * F1 - (c/2) * F2
-    
-    return h0 + jnp.dot(g1, μ) + jnp.dot(μ, jnp.dot(G2, μ))
-
-# Parameters
-T = 40
-β = 0.85
-c = 2
-α = 1
-u0 = 1
-u1 = 0.5
-u2 = 3
-
-# Initial guess for μ
-μ_init = jnp.zeros(T)
-
-# Calculate values using both functions
-V_val = compute_V(μ_init, β, c, α, u0, u1, u2)
-J_val = compute_J(μ_init, β, c, α, u0, u1, u2)
-V_val, J_val
-```
+I can write why we regard this as ML -- i.e., sort of brute force, but less brute force than than the earlier gradient method because here we recognize more about the mathematical structure of $V$.