```{math}

:label: cpi_fpb30

v^*(x) = \max_{0 \leq c \leq x}

v(x) = \max_{0 \leq c \leq x}

\left\{

u(c) + \beta \int v^*(f(x - c) z) \phi(dz)

u(c) + \beta \int v(f(x - c) z) \phi(dz)

\right\}

\quad \text{for all} \quad

x \in \mathbb R_+

```

Let the optimal consumption policy be denoted by $\sigma^*$.

Let $v^*$ be the value function and let $\sigma^*$ be the optimal consumption policy.

We know that $\sigma^*$ is a $v^*$-greedy policy so that $\sigma^*(x)$ is the maximizer in {eq}`cpi_fpb30`.

We know that $\sigma^*$ is a $v^*$-greedy policy.

The conditions above imply that

* $\sigma^*$ is the unique optimal policy for the optimal savings problem

* the optimal policy is continuous, strictly increasing and also **interior**, in the sense that $0 < \sigma^*(x) < x$ for all strictly positive $x$, and

* the optimal policy is continuous, strictly increasing and also **interior**,

in the sense that $0 < \sigma^*(x) < x$ for all strictly positive $x$, and

* the value function is strictly concave and continuously differentiable, with

```{math}

(v^*)'(x) = u' (\sigma^*(x) ) := (u' \circ \sigma^*)(x)

```

The last result is called the **envelope condition** due to its relationship with the [envelope theorem](https://en.wikipedia.org/wiki/Envelope_theorem).

The last result is called the **envelope condition** due to its relationship

with the [envelope theorem](https://en.wikipedia.org/wiki/Envelope_theorem).

To see why {eq}`cpi_env` holds, write the Bellman equation in the equivalent

form

This allows us to compare our results to the analytical solutions we obtained in

that lecture:

```{code-cell} python3

```{code-cell} ipython

def v_star(x, α, β, μ):

"""

True value function

We use the same `Model` structure from {doc}`os_stochastic`.

```{code-cell} python3

```{code-cell} ipython

class Model(NamedTuple):

u: Callable # utility function

f: Callable # production function

Here's the operator $K$, that implements the root-finding step.

```{code-cell} ipython3

```{code-cell} ipython

def K(σ: np.ndarray, model: Model) -> np.ndarray:

"""

The Coleman-Reffett operator

Let's generate an instance and plot some iterates of $K$, starting from $σ(x) = x$.

```{code-cell} python3

```{code-cell} ipython

# Define utility and production functions with derivatives

α = 0.4

u = lambda c: np.log(c)

using time iteration.

```{code-cell} python3

```{code-cell} ipython

def solve_model_time_iter(

model: Model,

σ_init: np.ndarray,

Let's call it:

```{code-cell} python3

```{code-cell} ipython

# Unpack

grid = model.grid

Here is a plot of the resulting policy, compared with the true policy:

```{code-cell} python3

```{code-cell} ipython

# Unpack

grid, α, β = model.grid, model.α, model.β

The maximal absolute deviation between the two policies is

```{code-cell} python3

```{code-cell} ipython

# Unpack

grid, α, β = model.grid, model.α, model.β

We define the CRRA utility function and its derivative.

```{code-cell} python3

```{code-cell} ipython

γ = 1.5

def u_crra(c):

Now we solve and plot the policy:

```{code-cell} python3

```{code-cell} ipython

%%time

# Unpack

grid = model_crra.grid