To see this, we first note that $X_t$ is normally distributed for each $t$.

This is immediate form {eq}`ar1_ma`, since linear combinations of independent

This is immediate from {eq}`ar1_ma`, since linear combinations of independent

normal random variables are normal.

Given that $X_t$ is normally distributed, we will know the full distribution

To see this, we just have to look at the dynamics of the first two moments, as

given in {eq}`dyn_tm`.

When $|a| < 1$, these sequence converge to the respective limits

When $|a| < 1$, these sequences converge to the respective limits

```{math}

:label: mu_sig_star

### The Bellman Operator

We introduce the **Bellman operator** $T$ that takes a function v as an

argument and returns a new function $Tv$ defined by.

argument and returns a new function $Tv$ defined by

$$

Tv(x) = \max_{0 \leq c \leq x} \{u(c) + \beta v(x - c)\}

### Fitted Value Function Iteration

Both consumption $c$ and the state variable $x$ are continous.

Both consumption $c$ and the state variable $x$ are continuous.

This causes complications when it comes to numerical work.

plt.show()

```

The fit is reasoable but not perfect.

The fit is reasonable but not perfect.

We can improve it by increasing the grid size or reducing the

error tolerance in the value function iteration routine.

### Exercise 1

We need to create a class to hold our primitives and return the right hand side of the bellman equation.

We need to create a class to hold our primitives and return the right hand side of the Bellman equation.

We will use [inheritance](https://en.wikipedia.org/wiki/Inheritance_%28object-oriented_programming%29) to maximize code reuse.

## Overview

This lecture and in {doc}`Cass-Koopmans Competitive Equilibrium <cass_koopmans_2>` describe a model that Tjalling Koopmans {cite}`Koopmans`

This lecture and lecture {doc}`Cass-Koopmans Competitive Equilibrium <cass_koopmans_2>` describe a model that Tjalling Koopmans {cite}`Koopmans`

and David Cass {cite}`Cass` used to analyze optimal growth.

The model can be viewed as an extension of the model of Robert Solow

described in [an earlier lecture](https://lectures.quantecon.org/py/python_oop.html)

but adapted to make the saving rate the outcome of an optimal choice.

(Solow assumed a constant saving rate determined outside the model).

(Solow assumed a constant saving rate determined outside the model.)

We describe two versions of the model, one in this lecture and the other in {doc}`Cass-Koopmans Competitive Equilibrium <cass_koopmans_2>`.

plot_paths(pp, 0.3, k_ss/3, [250, 150, 50, 25], k_ss=k_ss);

```

Different colors in the above graphs are associated

Different colors in the above graphs are associated with

different horizons $T$.

Notice that as the horizon increases, the planner puts $K_t$

In this lecture {doc}`Cass-Koopmans Planning Model <cass_koopmans_1>`, we computed an allocation $\{\vec{C}, \vec{K}, \vec{N}\}$

that solves the planning problem.

(This allocation will constitute the **Big** $K$ to be in the presence instance of the *Big** $K$ **, little** $k$ trick

(This allocation will constitute the **Big** $K$ to be in the present instance of the *Big** $K$ **, little** $k$ trick

that we'll apply to a competitive equilibrium in the spirit of [this lecture](https://lectures.quantecon.org/py/rational_expectations.html#)

and [this lecture](https://lectures.quantecon.org/py/dyn_stack.html#).)

We now turn to the problem faced by a firm in a competitive

equilibrium:

If we plug in {eq}`eq-pl` into {eq}`Zero-profits` for all t, we

If we plug {eq}`eq-pl` into {eq}`Zero-profits` for all t, we

get

$$

### Aperiodicity

Loosely speaking, a Markov chain is called periodic if it cycles in a predictible way, and aperiodic otherwise.

Loosely speaking, a Markov chain is called periodic if it cycles in a predictable way, and aperiodic otherwise.

Here's a trivial example with three states

A more stable and sophisticated algorithm is implemented in [QuantEcon.py](http://quantecon.org/quantecon-py).

This is the one we recommend you use:

This is the one we recommend you to use:

```{code-cell} python3

P = [[0.4, 0.6],

Let's now consider one of the most practical and important ranking problems

--- the rank assigned to web pages by search engines.

(Although the problem is motivated from outside of economics, there is in fact a deep connection between search ranking systems and prices in certain competitive equilibria --- see {cite}`DLP2013`)

(Although the problem is motivated from outside of economics, there is in fact a deep connection between search ranking systems and prices in certain competitive equilibria --- see {cite}`DLP2013`.)

To understand the issue, consider the set of results returned by a query to a web search engine.

The condition $\mathbb E | X_i | = \int |x| F(x) < \infty$ holds

in most cases but can fail if the distribution $F$ is very heavy tailed.

For example, it fails for the Cauchy distribution

For example, it fails for the Cauchy distribution.

Let's have a look at the behavior of the sample mean in this case, and see

whether or not the LLN is still valid.

2^{1/\alpha} = \exp(\mu)

$$

which we solve for $\mu$ and $\sigma$ given $\alpha = 1.05$

which we solve for $\mu$ and $\sigma$ given $\alpha = 1.05$.

Here is code that generates the two samples, produces the violin plot and

prints the mean and standard deviation of the two samples.

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 realisitic

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

can occur because $c_t$ cannot increase sufficiently to attain equality.

(The lower boundary case $c_t = 0$ never arises at the optimum because

$u'(0) = \infty$)

$u'(0) = \infty$.)

With some thought, one can show that {eq}`ee00` and {eq}`ee01` are

equivalent to

```{math}

:label: euler_diff_eq

u'(c)

- \max \left\{

u'(c) - \max \left\{

\beta R \, \mathbb E_z (u' \circ \sigma) \,

[R (a - c) + \hat Y, \, \hat Z]

\, , \;

Your task is to investigate how this measure of aggregate capital varies with

the interest rate.

Following tradition, put the price (i.e., interest rate) is on the vertical axis.

Following tradition, put the price (i.e., interest rate) on the vertical axis.

On the horizontal axis put aggregate capital, computed as the mean of the

stationary distribution given the interest rate.

We now have a clear path to successfully approximating the optimal policy:

choose some $\sigma \in \mathscr C$ and then iterate with $K$ until

convergence (as measured by the distance $\rho$)

convergence (as measured by the distance $\rho$).

### Using an Endogenous Grid

L(z, \hat z) := P(z, \hat z) \int R(\hat z, x) \phi(x) dx

$$

This indentity is proved in {cite}`ma2020income`, where $\phi$ is the

This identity is proved in {cite}`ma2020income`, where $\phi$ is the

density of the innovation $\zeta_t$ to returns on assets.

(Remember that $\mathsf Z$ is a finite set, so this expression defines a matrix.)

`ifp`, even though it would be more natural to just pass in `ifp` and then

solve inside the function.

The reason we do this is because `solve_model_time_iter` is not

The reason we do this is that `solve_model_time_iter` is not

JIT-compiled.

```{code-cell} python3

Such firms

1. wait until inventory falls below some level $s$ and then

1. order sufficent quantities to bring their inventory back up to capacity $S$.

1. order sufficient quantities to bring their inventory back up to capacity $S$.

These kinds of policies are common in practice and also optimal in certain circumstances.

We will do this by generating many draws of $X_T$ given initial

condition $X_0$.

With these draws of $X_T$ we can build up a picture of its distribution $\psi_T$

With these draws of $X_T$ we can build up a picture of its distribution $\psi_T$.

Here's one visualization, with $T=50$.

```

The function `operator_factory` takes an instance of this class and returns a

jitted version of the Bellman operator `T`, ie.

jitted version of the Bellman operator `T`, i.e.

$$

Tv(x)