Fix cross-references to renamed cake eating lectures

Updated all doc references throughout the lecture series to reflect the renamed files from PR #679:
- cake_eating_problem → cake_eating
- optgrowth → cake_eating_stochastic
- coleman_policy_iter → cake_eating_time_iter
- egm_policy_iter → cake_eating_egm

Also:
- Removed references to the deleted optgrowth_fast lecture
- Inlined solve_model_time_iter function in ifp.md
- Updated terminology from "stochastic optimal growth model" to "cake eating model" in ifp.md

This fixes the Jupyter Book build warnings about unknown documents.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: jstac

lectures/cake_eating_numerical.md

@@ -17,7 +17,7 @@ kernelspec:
 
 ## Overview
 
-In this lecture we continue the study of {doc}`the cake eating problem <cake_eating_problem>`.
+In this lecture we continue the study of {doc}`the cake eating problem <cake_eating>`.
 
 The aim of this lecture is to solve the problem using numerical
 methods.
@@ -44,7 +44,7 @@ from scipy.optimize import minimize_scalar, bisect
 
 ## Reviewing the Model
 
-You might like to {doc}`review the details <cake_eating_problem>` before we start.
+You might like to {doc}`review the details <cake_eating>` before we start.
 
 Recall in particular that the Bellman equation is
 
@@ -349,7 +349,7 @@ steep near the lower boundary, and hence hard to approximate.
 
 Let's see how this plays out in terms of computing the optimal policy.
 
-In the {doc}`first lecture on cake eating <cake_eating_problem>`, the optimal
+In the {doc}`first lecture on cake eating <cake_eating>`, the optimal
 consumption policy was shown to be
 
 $$

lectures/cake_eating_stochastic.md

@@ -27,7 +27,7 @@ kernelspec:
 ## Overview
 
 In this lecture, we continue our study of the cake eating problem, building on
-{doc}`Cake Eating I <cake_eating_problem>` and {doc}`Cake Eating II <cake_eating_numerical>`.
+{doc}`Cake Eating I <cake_eating>` and {doc}`Cake Eating II <cake_eating_numerical>`.
 
 The key difference from the previous lectures is that the cake size now evolves
 stochastically.
@@ -440,10 +440,6 @@ flexibility.
 Both of these things are helpful, but they do cost us some speed --- as you
 will see when you run the code.
 
-{doc}`Later <optgrowth_fast>` we will sacrifice some of this clarity and
-flexibility in order to accelerate our code with just-in-time (JIT)
-compilation.
-
 The algorithm we will use is fitted value function iteration, which was
 described in earlier lectures {doc}`the McCall model <mccall_fitted_vfi>` and
 {doc}`cake eating <cake_eating_numerical>`.
@@ -823,7 +819,7 @@ utility specification.
 
 Setting $\gamma = 1.5$, compute and plot an estimate of the optimal policy.
 
-Time how long this function takes to run, so you can compare it to faster code developed in the {doc}`next lecture <optgrowth_fast>`.
+Time how long this function takes to run.
 ```
 
 ```{solution-start} og_ex1
@@ -871,7 +867,6 @@ Time how long it takes to iterate with the Bellman operator
 
 Use the model specification in the previous exercise.
 
-(As before, we will compare this number with that for the faster code developed in the {doc}`next lecture <optgrowth_fast>`.)
 ```
 
 ```{solution-start} og_ex2

lectures/ifp.md

@@ -42,16 +42,16 @@ This is an essential sub-problem for many representative macroeconomic models
 * {cite}`Huggett1993`
 * etc.
 
-It is related to the decision problem in the {doc}`stochastic optimal growth model <optgrowth>` and yet differs in important ways.
+It is related to the decision problem in the {doc}`cake eating model <cake_eating_stochastic>` and yet differs in important ways.
 
 For example, the choice problem for the agent includes an additive income term that leads to an occasionally binding constraint.
 
 Moreover, in this and the following lectures, we will inject more realistic
 features such as correlated shocks.
 
 To solve the model we will use Euler equation based time iteration, which proved
-to be {doc}`fast and accurate <coleman_policy_iter>` in our investigation of
-the {doc}`stochastic optimal growth model <optgrowth>`.
+to be {doc}`fast and accurate <cake_eating_time_iter>` in our investigation of
+the {doc}`cake eating model <cake_eating_stochastic>`.
 
 Time iteration is globally convergent under mild assumptions, even when utility is unbounded (both above and below).
 
@@ -472,7 +472,31 @@ The following function iterates to convergence and returns the approximate
 optimal policy.
 
 ```{code-cell} python3
-:load: _static/lecture_specific/coleman_policy_iter/solve_time_iter.py
+def solve_model_time_iter(model,    # Class with model information
+                          σ,        # Initial condition
+                          tol=1e-4,
+                          max_iter=1000,
+                          verbose=True,
+                          print_skip=25):
+
+    # Set up loop
+    i = 0
+    error = tol + 1
+
+    while i < max_iter and error > tol:
+        σ_new = K(σ, model)
+        error = np.max(np.abs(σ - σ_new))
+        i += 1
+        if verbose and i % print_skip == 0:
+            print(f"Error at iteration {i} is {error}.")
+        σ = σ_new
+
+    if error > tol:
+        print("Failed to converge!")
+    elif verbose:
+        print(f"\nConverged in {i} iterations.")
+
+    return σ_new
 ```
 
 Let's carry this out using the default parameters of the `IFP` class:

lectures/ifp_advanced.md

@@ -251,7 +251,7 @@ convergence (as measured by the distance $\rho$).
 ### Using an Endogenous Grid
 
 In the study of that model we found that it was possible to further
-accelerate time iteration via the {doc}`endogenous grid method <egm_policy_iter>`.
+accelerate time iteration via the {doc}`endogenous grid method <cake_eating_egm>`.
 
 We will use the same method here.
 

lectures/lqcontrol.md

@@ -57,7 +57,7 @@ In reading what follows, it will be useful to have some familiarity with
 
 * matrix manipulations
 * vectors of random variables
-* dynamic programming and the Bellman equation (see for example {doc}`this lecture <intro:short_path>` and {doc}`this lecture <optgrowth>`)
+* dynamic programming and the Bellman equation (see for example {doc}`this lecture <intro:short_path>` and {doc}`this lecture <cake_eating_stochastic>`)
 
 For additional reading on LQ control, see, for example,
 

lectures/wald_friedman_2.md

@@ -451,7 +451,7 @@ class WaldFriedman:
         return π_new
 ```
 
-As in the {doc}`optimal growth lecture <optgrowth>`, to approximate a continuous value function
+As in {doc}`cake_eating_stochastic`, to approximate a continuous value function
 
 * We iterate at a finite grid of possible values of $\pi$.
 * When we evaluate $\mathbb E[J(\pi')]$ between grid points, we use linear interpolation.