25. Risk and Model Uncertainty#

25.1. Overview#

As an introduction to one possible approach to modeling Knightian uncertainty, this lecture describes static representations of five classes of preferences over risky prospects.

These preference specifications allow us to distinguish risk from uncertainty along lines proposed by [Knight, 1921].

All five preference specifications incorporate risk aversion, meaning displeasure from risks governed by well known probability distributions.

Two of them also incorporate uncertainty aversion, meaning dislike of not knowing a probability distribution.

The preference orderings are

• Expected utility preferences

• Constraint preferences

• Multiplier preferences

• Risk-sensitive preferences

• Ex post Bayesian expected utility preferences

This labeling scheme is taken from [Hansen and Sargent, 2001].

Constraint and multiplier preferences express aversion to not knowing a unique probability distribution that describes random outcomes.

Expected utility, risk-sensitive, and ex post Bayesian expected utility preferences all attribute a unique known probability distribution to a decision maker.

We present things in a simple before-and-after one-period setting.

In addition to learning about these preference orderings, this lecture also describes some interesting code for computing and graphing some representations of indifference curves, utility functions, and related objects.

Staring at these indifference curves provides insights into the different preferences.

Watch for the presence of a kink at the $45$ degree line for the constraint preference indifference curves.

We begin with some that we’ll use to create some graphs.

# Package imports
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib import rc, cm
from mpl_toolkits.mplot3d import Axes3D
from scipy import optimize, stats
from scipy.io import loadmat
from matplotlib.collections import LineCollection
from matplotlib.colors import ListedColormap, BoundaryNorm
from numba import njit

# Plotting parameters
%config InlineBackend.figure_format='retina'

plt.rc('text', usetex=True)

label_size = 20
label_tick_size = 18
title_size = 24
legend_size = 16
text_size = 18

mpl.rcParams['axes.labelsize'] = label_size 
mpl.rcParams['ytick.labelsize'] = label_tick_size 
mpl.rcParams['xtick.labelsize'] = label_tick_size 
mpl.rcParams['axes.titlesize'] = title_size
mpl.rcParams['legend.fontsize'] = legend_size
mpl.rcParams['font.size'] = text_size

# Useful functions
@njit
def ent(π, π_hat):
    """
    Compute the relative entropy of a probability vector `π_hat` with respect to `π`. JIT-compiled using Numba.
    
    """
    ent_val = -np.sum(π_hat * (np.log(π) - np.log(π_hat)))
    
    return ent_val


def T_θ_factory(θ, π):
    """
    Return an operator `T_θ` for a given penalty parameter `θ` and probability distribution vector `π`.
    
    """
    def T_θ(u):  
        """
        Risk-sensitivity operator of Jacobson (1973) and Whittle (1981) taking a function `u` as argument.
        
        """
        return lambda c: -θ * np.log(np.sum(π * np.exp(-u(c) / θ)))
    
    return T_θ


def compute_change_measure(u, c, θ, π):
    """
    Compute the channge of measure given a utility function `u`, a consumption vector `c`,
    a penalty parameter `θ` and a baseline probability vector `π` 
    
    """
    
    m_unnormalized = np.exp(-u(c) / θ)
    m =  m_unnormalized / (π * m_unnormalized).sum()
    return m


def utility_function_factory(α):
    """
    Return a CRRA utility function parametrized by `α` 
    
    """
    if α == 1.:
        return lambda c: np.log(c)
    else: 
        return lambda c: c ** (1 - α) / (1 - α)

25.2. Basic objects#

Basic ingredients are

• a set of states of the world

• plans describing outcomes as functions of the state of the world,

• a utility function mapping outcomes into utilities

• either a probability distribution or a set of probability distributions over states of the world; and

• a way of measuring a discrepancy between two probability distributions.

In more detail, we’ll work with the following setting.

• A finite set of possible states $\mathcal{I}=\{i=1,\dots ,I\}$.

• A (consumption) plan is a function $c:\mathcal{I}\to \mathbb{R}$.

• $u:\mathbb{R}\to \mathbb{R}$ is a utility function.

• $\pi$ is an $I\times 1$ vector of nonnegative probabilities over states, with ${\pi }_i\ge 0,\sum _{i=1}^I{\pi }_i=1$.

• Relative entropy $\text{ent}(\pi ,\hat{\pi })$ of a probability vector $\hat{\pi }$ with respect to a probability vector $\pi$ is the expected value of the logarithm of the likelihood ratio $m_i\doteq (\frac{{\hat{\pi }}_i}{{\pi }_i})$ under distribution $\hat{\pi }$ defined as:

or

Remark: A likelihood ratio $m_i$ is a discrete random variable. For any discrete random variable $\{x_i{\}}_{i=1}^I$, the expected value of $x$ under the ${\hat{\pi }}_i$ distribution can be represented as the expected value under the $\pi$ distribution of the product of $x_i$ times the `shock’ $m_i$:

where $\hat{E}$ is the mathematical expectation under the $\hat{\pi }$ distribution and $E$ is the expectation under the $\pi$ distribution.

Evidently,

and relative entropy is

In the three figures below, we plot relative entropy from several perspectives.

Our first figure depicts entropy as a function of ${\hat{\pi }}_1$ when $I=2$ and ${\pi }_1=.5$.

When ${\pi }_1\in (0,1)$, entropy is finite for both ${\hat{\pi }}_1=0$ and ${\hat{\pi }}_1=1$ because $\underset{x\to 0}{lim}x\log x=0$

However, when ${\pi }_1=0$ or ${\pi }_1=1$, entropy is infinite.

# Specify baseline probability vector `π`
π = np.array([0.5, 0.5])

# Construct grid for `π_hat_0` values
min_prob = 1e-2
π_hat_0_nb = 201
π_hat_0_vals = np.linspace(min_prob, 1 - min_prob, num=π_hat_0_nb)

# Initialize `π_hat` vector with arbitrary values
π_hat = np.empty(2)

# Initialize `ent_vals` to store entropy values
ent_vals = np.empty(π_hat_0_vals.size)

for i in range(π_hat_0_vals.size):  # Loop over all possible values for `π_hat_0` 
    # Update `π_hat` values
    π_hat[0] = π_hat_0_vals[i]
    π_hat[1] = 1 - π_hat_0_vals[i]
    
    # Compute and store entropy value
    ent_vals[i] = ent(π, π_hat)

Show code cell source

Hide code cell source

plt.figure(figsize=(5, 3))
plt.plot(π_hat_0_vals, ent_vals, color='blue');
plt.ylabel(r'entropy ($\pi_{1}=%.2f$)' % π[0] );
plt.xlabel(r'$\hat{\pi}_1$');
plt.show()

The heat maps in the next two figures vary both ${\hat{\pi }}_1$ and ${\pi }_1$.

The following figure plots entropy.

# Use same grid for `π_0_vals` as for `π_hat_0_vals` 
π_0_vals = π_hat_0_vals.copy() 

# Initialize matrix of entropy values
ent_vals_mat = np.empty((π_0_vals.size, π_hat_0_vals.size))

for i in range(π_0_vals.size):  # Loop over all possible values for `π_0` 
    # Update `π` values
    π[0] = π_0_vals[i]
    π[1] = 1 - π_0_vals[i]
    
    for j in range(π_hat_0_vals.size):  # Loop over all possible values for `π_hat_0` 
        # Update `π_hat` values
        π_hat[0] = π_hat_0_vals[j]
        π_hat[1] = 1 - π_hat_0_vals[j]
        
        # Compute and store entropy value
        ent_vals_mat[i, j] = ent(π, π_hat)

Show code cell source

Hide code cell source

x, y = np.meshgrid(π_0_vals, π_hat_0_vals)
plt.figure(figsize=(10, 8))
plt.pcolormesh(x, y, ent_vals_mat.T, cmap='seismic', shading='gouraud')
plt.colorbar();
plt.ylabel(r'$\hat{\pi}_1$');
plt.xlabel(r'$\pi_1$');
plt.title('Entropy Heat Map');
plt.show()

The next figure plots the logarithm of entropy.

# Check the point (0.01, 0.9)
π = np.array([0.01, 0.99])
π_hat = np.array([0.9, 0.1])
ent(π, π_hat)

3.8205752275831846

Show code cell source

Hide code cell source

plt.figure(figsize=(10, 8))
plt.pcolormesh(x, y, np.log(ent_vals_mat.T), shading='gouraud', cmap='seismic')
plt.colorbar()
plt.ylabel(r'$\hat{\pi}_1$');
plt.xlabel(r'$\pi_1$');
plt.title('Log Entropy Heat Map');
plt.show()

/tmp/ipykernel_7948/3759713737.py:2: RuntimeWarning: divide by zero encountered in log
  plt.pcolormesh(x, y, np.log(ent_vals_mat.T), shading='gouraud', cmap='seismic')

25.3. Five preference specifications#

We describe five types of preferences over plans.

• Expected utility preferences

• Constraint preferences

• Multiplier preferences

• Risk-sensitive preferences

• Ex post Bayesian expected utility preferences

Expected utility, risk-sensitive, and ex post Bayesian prefernces are each cast in terms of a unique probability distribution, so they can express risk-aversion, but not model ambiguity aversion.

Multiplier and constraint prefernces both express aversion to concerns about model misppecification, i.e., model uncertainty; both are cast in terms of a set or sets of probability distributions.

• The set of distributions expresses the decision maker’s ambiguity about the probability model.

• Minimization over probability distributions expresses his aversion to ambiguity.

25.4. Expected utility#

A decision maker is said to have expected utility preferences when he ranks plans $c$ by their expected utilities

where $u$ is a unique utility function and $\pi$ is a unique probability measure over states.

• A known $\pi$ expresses risk.

• Curvature of $u$ expresses risk aversion.

25.5. Constraint preferences#

A decision maker is said to have constraint preferences when he ranks plans $c$ according to

subject to

and

In (25.3), $\eta \ge 0$ defines an entropy ball of probability distributions $\hat{\pi }=m\pi$ that surround a baseline distribution $\pi$.

As noted earlier, $\sum _{i=1}^I{m}_i{\pi }_{i}u(c_i)$ is the expected value of $u(c)$ under a twisted probability distribution $\{{\hat{\pi }}_i{\}}_{i=1}^I=\{m_i{\pi }_i{\}}_{i=1}^I$.

Larger values of the entropy constraint $\eta$ indicate more apprehension about the baseline probability distribution $\{{\pi }_i{\}}_{i=1}^I$.

Following [Hansen and Sargent, 2001] and [Hansen and Sargent, 2008], we call minimization problem (25.2) subject to (25.3) and(25.4) a constraint problem.

To find minimizing probabilities, we form a Lagrangian

where $\tilde{\theta }\ge 0$ is a Lagrange multiplier associated with the entropy constraint.

Subject to the additional constraint that $\sum _{i=1}^I{m}_i{\pi }_i=1$, we want to minimize (25.5) with respect to $\{m_i{\}}_{i=1}^I$ and to maximize it with respect to $\tilde{\theta }$.

The minimizing probability distortions (likelihood ratios) are

To compute the Lagrange multiplier $\tilde{\theta }(c,\eta )$, we must solve

or

for $\tilde{\theta }=\tilde{\theta }(c;\eta )$.

For a fixed $\eta$, the $\tilde{\theta }$ that solves equation (25.7) is evidently a function of the consumption plan $c$.

With $\tilde{\theta }(c;\eta )$ in hand we can obtain worst-case probabilities as functions ${\pi }_i{\tilde{m}}_i(c;\eta )$ of $\eta$.

The indirect (expected) utility function under constraint preferences is

Entropy evaluated at the minimizing probability distortion (25.6) equals $E\tilde{m}\log \tilde{m}$ or

Expression (25.9) implies that

where the last term is $\tilde{\theta }$ times the entropy of the worst-case probability distribution.

25.6. Multiplier preferences#

A decision maker is said to have multiplier preferences when he ranks consumption plans $c$ according to

where minimization is subject to

Here $\theta \in (\underset{―}{\theta },+\mathrm{\infty })$ is a ‘penalty parameter’ that governs a ‘cost’ to an ‘evil alter ego’ who distorts probabilities by choosing $\{m_i{\}}_{i=1}^I$.

Lower values of the penalty parameter $\theta$ express more apprehension about the baseline probability distribution $\pi$.

Following [Hansen and Sargent, 2001] and [Hansen and Sargent, 2008], we call the minimization problem on the right side of (25.11) a multiplier problem.

The minimizing probability distortion that solves the multiplier problem is

We can solve

to find an entropy level $\tilde{\eta }(c;\theta )$ associated with multiplier preferences with penalty parameter $\theta$ and allocation $c$.

For a fixed $\theta$, the $\tilde{\eta }$ that solves equation (25.13) is a function of the consumption plan $c$

The forms of expressions (25.6) and (25.12) are identical, but the Lagrange multiplier $\tilde{\theta }$ appears in (25.6), while the penalty parameter $\theta$ appears in (25.12).

Formulas (25.6) and (25.12) show that worst-case probabilities are context specific in the sense that they depend on both the utility function $u$ and the consumption plan $c$.

If we add $\theta$ times entropy under the worst-case model to expected utility under the worst-case model, we find that the indirect expected utility function under multiplier preferences is

25.7. Risk-sensitive preferences#

Substituting ${\hat{m}}_i$ into $\sum _{i=1}^I{\pi }_i{\hat{m}}_i[u(c_i)+\theta \log {\hat{m}}_i]$ gives the indirect utility function

Here $\mathsf{T}u$ in (25.15) is the risk-sensitivity operator of [Jacobson, 1973], [Whittle, 1981], and [Whittle, 1990].

It defines a risk-sensitive preference ordering over plans $c$.

Because it is not linear in utilities $u(c_i)$ and probabilities ${\pi }_i$, it is said not to be separable across states.

Because risk-sensitive preferences use a unique probability distribution, they apparently express no model distrust or ambiguity.

Instead, they make an additional adjustment for risk-aversion beyond that embedded in the curvature of $u$.

For $I=2,c_1=2,c_2=1$, $u(c)=\ln c$, the following figure plots the risk-sensitive criterion $\mathsf{T}u(c)$ defined in (25.15) as a function of ${\pi }_1$ for values of $\theta$ of 100 and .6.

c_bundle = np.array([2., 1.])  # Consumption bundle
θ_vals = np.array([100, 0.6])  # Array containing the different values of θ
u = utility_function_factory(1.)  # Utility function

# Intialize arrays containing values for Tu(c)
Tuc_vals = np.empty((θ_vals.size, π_hat_0_vals.size))

for i in range(θ_vals.size):  # Loop over θ values
    for j in range(π_hat_0_vals.size):  # Loop over `π_hat_0` values
        # Update `π` values
        π[0] = π_0_vals[j]
        π[1] = 1 - π_0_vals[j]

        # Create T operator
        T = T_θ_factory(θ_vals[i], π)
        
        # Apply T operator to utility function
        Tu = T(u)
        
        # Compute and store Tu(c)
        Tuc_vals[i, j] = Tu(c_bundle)

Show code cell source

Hide code cell source

plt.figure(figsize=(10, 8))
plt.plot(π_0_vals, Tuc_vals[0], label=r'$\theta=100$', color='blue');
plt.plot(π_0_vals, Tuc_vals[1], label=r'$\theta=0.6$', color='red');
plt.ylabel(r'$\mathbf{T}u\left(c\right)$');
plt.xlabel(r'$\pi_1$');
plt.legend();

For large values of $\theta$, $\mathsf{T}u(c)$ is approximately linear in the probability ${\pi }_1$, but for lower values of $\theta$, $\mathsf{T}u(c)$ has considerable curvature as a function of ${\pi }_1$.

Under expected utility, i.e., $\theta =+\mathrm{\infty }$, $\mathsf{T}u(c)$ is linear in ${\pi }_1$, but it is convex as a function of ${\pi }_1$ when $\theta <+\mathrm{\infty }$.

The two panels in the next figure below can help us to visualize the extra adjustment for risk that the risk-sensitive operator entails.

This will help us understand how the $\mathbf{T}$ transformation works by envisioning what function is being averaged.

# Parameter values
θ= 0.8
π = np.array([0.5, 0.5])
c_bundle = np.array([2., 1.])  # Consumption bundle

# Compute the average consumption level implied by `c_bundle` wrt to `π` 
avg_c_bundle = np.sum(π * c_bundle)

# Construct grid for consumption values
c_grid_nb = 101
c_grid = np.linspace(0.5, 2.5, num=c_grid_nb)

# Evaluate utility function on the grid
u_c_grid = u(c_grid)

# Evaluate utility function at bundle points
u_c_bundle = u(c_bundle)

# Compute the average utility level implied by `c_bundle` wrt to `π` 
avg_u = np.sum(π * u_c_bundle)

# Compute the first transformation exp(-u(c) / θ) for grid values
first_trnsf_u_c_grid = np.exp(-u_c_grid / θ) 

# Compute the first transformation exp(-u(c) / θ) for bundle values
first_trnsf_u_c_bundle = np.exp(-u_c_bundle/θ)

# Take expectations in the transformed space for bundle values (second transformation)
second_trnsf_u_c_bundle = np.sum(π * first_trnsf_u_c_bundle)

# Send expectation back to the original space (third transformation)
third_trnsf_u_c_bundle = -θ * np.log(second_trnsf_u_c_bundle)

Show code cell source

Hide code cell source

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6), sharex=True, sharey=True)

ax1.plot(c_grid, u_c_grid, label=r'$\log\left(c\right)$', color='blue')
ax1.plot(c_bundle, u_c_bundle, color='red')
ax1.plot(avg_c_bundle, third_trnsf_u_c_bundle, 'o', color='green');
ax1.annotate(r'$-\theta\log E\left[\exp\left(\frac{-\log\left(c\right)}{\theta}\right)\right]$',
             (avg_c_bundle+0.05, third_trnsf_u_c_bundle-0.15))

# Consumption dots
ax1.plot(c_bundle[0], u_c_bundle[0], 'o', color='black')
ax1.plot(c_bundle[1], u_c_bundle[1], 'o', color='black')
ax1.annotate(r'$c_1$', (c_bundle[0]-0.08, u_c_bundle[0]+0.03))
ax1.annotate(r'$c_2$', (c_bundle[1]-0.08, u_c_bundle[1]+0.03))
ax1.set_xlabel(r'$c$')

ax1.set_title('Original space')
ax1.legend()

ax2.plot(c_grid, first_trnsf_u_c_grid, label=r'$\exp\left(\frac{-\log\left(c\right)}{\theta}\right)$', color='blue');
ax2.plot(c_bundle, first_trnsf_u_c_bundle, color='red')
ax2.plot(avg_c_bundle, second_trnsf_u_c_bundle, 'o', color='green')
ax2.annotate(r'$E\left[\exp\left(\frac{-\log\left(c\right)}{\theta}\right)\right]$',
             (avg_c_bundle+0.05, second_trnsf_u_c_bundle+0.08))

# Consumption dots
ax2.plot(c_bundle[0], first_trnsf_u_c_bundle[0], 'o', color='black')
ax2.plot(c_bundle[1], first_trnsf_u_c_bundle[1], 'o', color='black')
ax2.annotate(r'$c_1$', (c_bundle[0], first_trnsf_u_c_bundle[0]+0.05))
ax2.annotate(r'$c_2$', (c_bundle[1], first_trnsf_u_c_bundle[1]+0.05))
ax2.set_xlabel(r'$c$')

ax2.set_title('Transformed space')
ax2.legend();

The panel on the right portrays how the transformation $\exp \left(\frac{-u\left(c\right)}{\theta }\right)$ sends $u\left(c\right)$ to a new function by (i) flipping the sign, and (ii) increasing curvature in proportion to $\theta$.

In the left panel, the red line is our tool for computing the mathematical expectation for different values of $\pi$.

The green lot indicates the mathematical expectation of $\exp \left(\frac{-u\left(c\right)}{\theta }\right)$ when $\pi =.5$.

Notice that the distance between the green dot and the curve is greater in the transformed space than the original space as a result of additional curvature.

The inverse transformation $\theta \log E[\exp \left(\frac{-u\left(c\right)}{\theta }\right)]$ generates the green dot on the left panel that constitutes the risk-sensitive utility index.

The gap between the green dot and the red line on the left panel measures the additional adjustment for risk that risk-sensitive preferences make relative to plain vanilla expected utility preferences.

25.8. Ex post Bayesian preferences#

A decision maker is said to have ex post Bayesian preferences when he ranks consumption plans according to the expected utility function

where $\hat{\pi }(c^{\ast })$ is the worst-case probability distribution associated with multiplier or constraint preferences evaluated at a particular consumption plan $c^{\ast }=\{c_i^{\ast }{\}}_{i=1}^I$.

At $c^{\ast }$, an ex post Bayesian’s indifference curves are tangent to those for multiplier and constraint preferences with appropriately chosen $\theta$ and $\eta$, respectively.

25.9. Comparing preferences#

For the special case in which $I=2$, $c_1=2,c_2=1$, $u(c)=\ln c$, and ${\pi }_1=.5$, the following two figures depict how worst-case probabilities are determined under constraint and multiplier preferences, respectively.

The first figure graphs entropy as a function of ${\hat{\pi }}_1$.

It also plots expected utility under the twisted probability distribution, namely, $\hat{E}u(c)=u(c_2)+{\hat{\pi }}_1(u(c_1)-u(c_2))$, which is evidently a linear function of ${\hat{\pi }}_1$.

The entropy constraint $\sum _{i=1}^I{\pi }_i{m}_i\log m_i\le \eta$ implies a convex set ${\hat{\mathrm{\Pi }}}_1$ of ${\hat{\pi }}_1$’s that constrains the adversary who chooses ${\hat{\pi }}_1$, namely, the set of ${\hat{\pi }}_1$’s for which the entropy curve lies below the horizontal dotted line at an entropy level of $\eta =.25$.

Unless $u(c_1)=u(c_2)$, the ${\hat{\pi }}_1$ that minimizes $\hat{E}u(c)$ is at the boundary of the set ${\hat{\mathrm{\Pi }}}_1$.

# Parameter 
η = 0.25
π = np.array([0.5, 0.5])
c_bundle = np.array([2., 1.])  # Consumption bundle

# Create η array for putting an upper bound on entropy values
η_line = np.ones_like(π_hat_0_vals.size) * η

# Initialize array for storing values for \hat{E}[u(c)]
E_hat_uc = np.empty(π_hat_0_vals.size)

for i in range(π_hat_0_vals.size):  # Loop over π_hat_0
    # Compute and store \hat{E}[u(c)]
    E_hat_uc[i] = u(c_bundle[1]) + π_hat_0_vals[i] * (u(c_bundle[0]) - u(c_bundle[1]))

# Set up a root finding problem to find the solution to the constraint problem
# First argument to `root_scalar` is a function that takes a value for π_hat_0 and returns 
# the entropy of π_hat wrt π minus η
root = optimize.root_scalar(lambda x: ent(π, np.array([x, 1-x])) - η, bracket=[1e-4, 0.5]).root

Show code cell source

Hide code cell source

plt.figure(figsize=(12, 8))
plt.plot(π_hat_0_vals, E_hat_uc, label=r'$\hat{E}u\left(c\right)$', color='blue')
plt.fill_between(π_hat_0_vals, η_line, alpha=0.3, label=r'$\mathrm{ent}\left(\pi,\hat{\pi}\right)\leq\eta$',
                 color='gray',
                 linewidth=0.0)
plt.plot(π_hat_0_vals, ent_vals, label=r'$\mathrm{ent}\left(\pi,\hat{\pi}\right)$', color='red')
plt.plot(root, η, 'o', color='black', label='constraint problem solution')
plt.xlabel(r'$\hat{\pi}_1$');
plt.legend();

The next figure shows the function $\sum _{i=1}^I{\pi }_i{m}_i[u(c_i)+\theta \log m_i]$ that is to be minimized in the multiplier problem.

The argument of the function is ${\hat{\pi }}_1=m_1{\pi }_1$.

# Parameter values
θ_vals = np.array([0.42, 1.])

# Initialize values for storing the multiplier criterion values
multi_crit_vals = np.empty((θ_vals.size, π_hat_0_vals.size))

for i in range(θ_vals.size):  # Loop over θ values
    for j in range(π_hat_0_vals.size):  # Loop over π_hat_0 values
        # Update `π_hat` values
        π_hat[0] = π_hat_0_vals[j]
        π_hat[1] = 1 - π_hat_0_vals[j]
        
        # Compute distorting measure
        m_i = π_hat / π
        
        # Compute and store multiplier criterion objective value
        multi_crit_vals[i, j] = np.sum(π_hat * (u(c_bundle) + θ_vals[i] * np.log(m_i)))

Show code cell source

Hide code cell source

plt.figure(figsize=(12, 8))

# Expected utility values
plt.plot(π_hat_0_vals, E_hat_uc, label=r'$\hat{E}u\left(c\right)$', color='blue')

# First multiplier criterion objective values
plt.plot(π_hat_0_vals, multi_crit_vals[0],
         label=r'$\sum_{i=1}^{I}\pi_{i}m_{i}\left[u\left(c_{i}\right)+0.42\log\left(m_{i}\right)\right]$',
         color='green')

# Second multiplier criterion objective values
plt.plot(π_hat_0_vals, multi_crit_vals[1],
         label=r'$\sum_{i=1}^{I}\pi_{i}m_{i}\left[u\left(c_{i}\right)+\log\left(m_{i}\right)\right]$',
         color='purple')

# Entropy values
plt.plot(π_hat_0_vals, ent_vals, label=r'$\mathrm{ent}\left(\pi,\hat{\pi}\right)$', color='red')

# Area fill
plt.fill_between(π_hat_0_vals, η_line, alpha=0.3, label=r'$\mathrm{ent}\left(\pi,\hat{\pi}\right)\leq\eta$', color='gray')

# Problem solution dots
plt.plot(root, η, 'o', color='black', label='constraint problem solution')
plt.plot(π_hat_0_vals[multi_crit_vals[0].argmin()], multi_crit_vals[0].min(), 'o', label='multiplier problem solution', color='darkred')
plt.plot(π_hat_0_vals[multi_crit_vals[1].argmin()], multi_crit_vals[1].min(), 'o', color='darkred')

plt.xlabel(r'$\hat{\pi}_1$');
plt.legend();

Evidently, from this figure and also from formula (25.12), lower values of $\theta$ lead to lower, and thus more distorted, minimizing values of ${\hat{\pi }}_1$.

The figure indicates how one can construct a Lagrange multiplier $\tilde{\theta }$ associated with a given entropy constraint $\eta$ and a given consumption plan.

Thus, to draw the figure, we set the penalty parameter for multiplier preferences $\theta$ so that the minimizing ${\hat{\pi }}_1$ equals the minimizing ${\hat{\pi }}_1$ for the constraint problem from the previous figure.

The penalty parameter $\theta =.42$ also equals the Lagrange multiplier $\tilde{\theta }$ on the entropy constraint for the constraint preferences depicted in the previous figure because the ${\hat{\pi }}_1$ that minimizes the asymmetric curve associated with penalty parameter $\theta =.42$ is the same ${\hat{\pi }}_1$ associated with the intersection of the entropy curve and the entropy constraint dashed vertical line.

25.10. Risk aversion and misspecification aversion#

All five types of preferences use curvature of $u$ to express risk aversion.

Constraint preferences express concern about misspecification or ambiguity for short with a positive $\eta$ that circumscribes an entropy ball around an approximating probability distribution $\pi$, and aversion aversion to model misspecification through minimization with respect to a likelihood ratio $m$.

Multiplier preferences express misspecification concerns with a parameter $\theta <+\mathrm{\infty }$ that penalizes deviations from the approximating model as measured by relative entropy, and they express aversion to misspecification concerns with minimization over a probability distortion $m$.

By penalizing minimization over the likelihood ratio $m$, a decrease in $\theta$ represents an increase in ambiguity (or what [Knight, 1921] called uncertainty) about the specification of the baseline approximating model $\{{\pi }_i{\}}_{i=1}^I$.

Formulas (25.6) assert that the decision maker acts as if he is pessimistic relative to an approximating model $\pi$.

It expresses what [Bucklew, 2004] [p. 27] calls a statistical version of Murphy’s law:

$$ The probability of anything happening is in inverse ratio to its desirability.

The minimizing likelihood ratio $\hat{m}$ slants worst-case probabilities $\hat{\pi }$ exponentially to increase probabilities of events that give lower utilities.

As expressed by the value function bound (25.19) to be displayed below, the decision maker uses pessimism instrumentally to protect himself against model misspecification.

The penalty parameter $\theta$ for multipler preferences or the entropy level $\eta$ that determines the Lagrange multiplier $\tilde{\theta }$ for constraint preferences controls how adversely the decision maker exponentially slants probabilities.

A decision rule is said to be undominated in the sense of Bayesian decision theory if there exists a probability distribution $\pi$ for which it is optimal.

A decision rule is said to be admissible if it is undominated.

[Hansen and Sargent, 2008] use ex post Bayesian preferences to show that robust decision rules are undominated and therefore admissible.

25.11. Indifference curves#

Indifference curves illuminate how concerns about robustness affect asset pricing and utility costs of fluctuations. For $I=2$, the slopes of the indifference curves for our five preference specifications are

• Expected utility:

  $$\frac{d{c}_2}{d{c}_1}=-\frac{{\pi }_1}{{\pi }_2}\frac{u^{\prime }(c_1)}{u^{\prime }(c_2)}$$

• Constraint and ex post Bayesian preferences:

  $$\frac{d{c}_2}{d{c}_1}=-\frac{{\hat{\pi }}_1}{{\hat{\pi }}_2}\frac{u^{\prime }(c_1)}{u^{\prime }(c_2)}$$

  where ${\hat{\pi }}_1,{\hat{\pi }}_2$ are the minimizing probabilities computed from the worst-case distortions (25.6) from the constraint problem at $(c_1,c_2)$.

• Multiplier and risk-sensitive preferences:

  $$\frac{d{c}_2}{d{c}_1}=-\frac{{\pi }_1}{{\pi }_2}\frac{\exp (-u(c_1)/\theta )}{\exp (-u(c_2)/\theta )}\frac{u^{\prime }(c_1)}{u^{\prime }(c_2)}$$

When $c_1>c_2$, the exponential twisting formula (25.12) implies that ${\hat{\pi }}_1<{\pi }_1$, which in turn implies that the indifference curves through $(c_1,c_2)$ for both constraint and multiplier preferences are flatter than the indifference curve associated with expected utility preferences.

As we shall see soon when we discuss state price deflators, this gives rise to higher estimates of prices of risk.

For an example with $u(c)=\ln c$, $I=2$, and ${\pi }_1=.5$, the next two figures show indifference curves for expected utility, multiplier, and constraint preferences.

The following figure shows indifference curves going through a point along the 45 degree line.

def multiplier_criterion_factory(θ, π, u):
    """
    Return a function to compute the multiplier preferences objective function parametrized 
    by a penalty parameter `θ`, a probability vector `π` and a utility function `u`
    
    """
    def criterion(c_1, c_2, return_entropy=False):
        """
        Compute the multiplier preferences objective function and
        associated entropy level if return_entropy=True for a
        consumption bundle (c_1, c_2).
        
        """
        # Compute the distorting measure
        m = compute_change_measure(u, np.array([c_1, c_2]), θ, π)
        
        # Compute objective value
        obj = π[0] * m[0] * (u(c_1) + θ * np.log(m[0])) + π[1] * m[1] * (u(c_2) + θ * np.log(m[1]))
        
        if return_entropy:        
            # Compute associated entropy value
            π_hat = np.array([π[0] * m[0], π[1] * m[1]])
            ent_val = ent(π, π_hat)
        
            return ent_val
        
        else:
            return obj
    
    return criterion


def constraint_criterion_factory(η, π, u):
    """
    Return a function to compute the constraint preferences objective function parametrized 
    by a penalty parameter `η`, a probability vector `π` and a utility function `u`
    
    """
    
    def inner_root_problem(θ_tilde, c_1, c_2):
        """
        Inner root problem associated with the constraint preferences objective function. 
        
        """
        # Compute the change of measure
        m = compute_change_measure(u, np.array([c_1, c_2]), θ_tilde, π)
            
        # Compute the associated entropy value
        π_hat = np.array([π[0] * m[0], π[1] * m[1]])
        ent_val = ent(π, π_hat)
        
        # Compute the error
        Δ = ent_val - η
        
        return ent_val - η
    
    def criterion(c_1, c_2, return_θ_tilde=False):
        try:
            # Solve for the Lagrange multiplier
            res = optimize.root_scalar(inner_root_problem, args=(c_1, c_2), bracket=[3e-3, 10.], method='bisect')
            
            if res.converged:
                θ_tilde = res.root

                # Compute change of measure
                m = compute_change_measure(u, np.array([c_1, c_2]), θ_tilde, π)

                obj = π[0] * m[0] * u(c_1) + π[1] * m[1] * u(c_2)

                if return_θ_tilde: 
                    return θ_tilde

                else: 
                    return obj

            else: 
                return np.nan
            
        except: 
            return np.nan
        
    return criterion


def solve_root_problem(problem, u_bar, c_1_grid, method='bisect', bracket=[0.5, 3.]):
    """
    Solve root finding problem `problem` for all values in `c_1_grid` taking `u_bar` as
    given and using `method`.
    
    """
    
    # Initialize array to be filled with c_2 values
    c_2_grid = np.empty(c_1_grid.size)
    
    for i in range(c_1_grid.size):  # Loop over c_1 values
        c_1 = c_1_grid[i]
        
        try: 
            # Solve root problem given c_1 and u_bar
            res = optimize.root_scalar(problem, args=(c_1, u_bar), bracket=bracket, method=method)

            if res.converged:  # Store values if successfully converged
                c_2_grid[i] = res.root
            else:  # Store np.nan otherwise
                c_2_grid[i] = np.nan
                
        except:
            c_2_grid[i] = np.nan
            
    return c_2_grid

# Parameters
c_bundle = np.array([1., 1.])  # Consumption bundle
u_inv = lambda x: np.exp(x)  # Inverse of the utility function
θ = 1.
η = 0.12


# Conustruct grid for c_1
c_1_grid_nb = 102
c_1_grid = np.linspace(0.5, 2., num=c_1_grid_nb)

# Compute \bar{u}
u_bar = u(c_bundle) @ π

# Compute c_2 values for the expected utility case
c_2_grid_EU = u_inv((u_bar - u(c_1_grid) * π[0]) / π[1])

# Compute c_2 values for the multiplier preferences case
multi_pref_crit = multiplier_criterion_factory(θ, π, u)  # Create criterion
multi_pref_root_problem = lambda c_2, c_1, u_bar: u_bar - multi_pref_crit(c_1, c_2)  # Formulate root problem
c_2_grid_mult = solve_root_problem(multi_pref_root_problem, u_bar, c_1_grid)  # Solve root problem for all c_1 values

# Compute c_2 values for the constraint preferences case
constraint_pref_crit = constraint_criterion_factory(η, π, u)  # Create criterion
constraint_pref_root_problem = lambda c_2, c_1, u_bar: u_bar - constraint_pref_crit(c_1, c_2)  # Formulate root problem
# Solve root problem for all c_1 values
c_2_grid_cons = solve_root_problem(constraint_pref_root_problem, u_bar, c_1_grid, method='bisect', bracket=[0.5, 2.5])  

# Compute associated η and θ values
ηs = np.empty(c_1_grid.size)
θs = np.empty(c_1_grid.size)

for i in range(c_1_grid.size):
    ηs[i] = multi_pref_crit(c_1_grid[i], c_2_grid_mult[i], return_entropy=True)
    θs[i] = constraint_pref_crit(c_1_grid[i], c_2_grid_cons[i], return_θ_tilde=True)
    
θs[~np.isfinite(c_2_grid_cons)] = np.nan

Show code cell source

Hide code cell source

f, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8), sharex=True)

ax1.plot(c_1_grid, c_1_grid, '--', color='black')
ax1.plot(c_1_grid, c_2_grid_EU, label='Expected Utility', color='blue')
ax1.plot(c_1_grid, c_2_grid_mult, label='Multiplier Preferences', color='red')
ax1.plot(c_1_grid, c_2_grid_cons, label='Constraint Preferences', color='green')
ax1.plot(1., 1., 'o', color='black')
ax1.set_xlabel(r'$c_1$')
ax1.set_ylabel(r'$c_2$')
ax1.annotate('(1, 1)', (1-0.16, 1-0.02))
ax1.set_ylim(0.5, 2.)
ax1.set_xlim(0.5, 2.)
ax1.legend();

ax2.plot(c_1_grid, ηs, label=r'$\eta^{*}$', color='red')
ax2.plot(c_1_grid, θs, label=r'$\theta^{*}$', color='green')
ax2.set_xlabel(r'$c_1$')
ax2.legend();

Kink at 45 degree line

Notice the kink in the indifference curve for constraint preferences at the 45 degree line.

To understand the source of the kink, consider how the Lagrange multiplier and worst-case probabilities vary with the consumption plan under constraint preferences.

For fixed $\eta$, a given plan $c$, and a utility function increasing in $c$, worst case probabilities are fixed numbers ${\hat{\pi }}_1<.5$ when $c_1>c_2$ and ${\hat{\pi }}_1>.5$ when $c_2>c_1$.

This pattern makes the Lagrange multiplier $\tilde{\theta }$ vary discontinuously at ${\hat{\pi }}_1=.5$.

The discontinuity in the worst case ${\hat{\pi }}_1$ at the 45 degree line accounts for the kink at the 45 degree line in an indifference curve for constraint preferences associated with a given positive entropy constraint $\eta$.

The code for generating the preceding figure is somewhat intricate we formulate a root finding problem for finding indifference curves.

Here is a brief literary description of the method we use.

Parameters

• Consumption bundle $c=(1,1)$

• Penalty parameter $\theta =2$

• Utility function $u=\log$

• Probability vector $\pi =(0.5,0.5)$

Algorithm:

• Compute $\overline{u}={\pi }_{1}u\left(c_1\right)+{\pi }_{2}u\left(c_2\right)$

• Given values for $c_1$, solve for values of $c_2$ such that $\overline{u}=u(c_1,c_2)$:

  • Expected utility: $c_{2,EU}=u^{-1}\left(\frac{\overline{u}-{\pi }_{1}u\left(c_1\right)}{{\pi }_2}\right)$

  • Multiplier preferences: solve $\overline{u}-\sum _i{\pi }_i\frac{\exp \left(\frac{-u\left(c_i\right)}{\theta }\right)}{\sum _j\exp \left(\frac{-u\left(c_j\right)}{\theta }\right)}(u\left(c_i\right)+\theta \log \left(\frac{\exp \left(\frac{-u\left(c_i\right)}{\theta }\right)}{\sum _j\exp \left(\frac{-u\left(c_j\right)}{\theta }\right)}\right))=0$ numerically

  • Constraint preference: solve $\overline{u}-\sum _i{\pi }_i\frac{\exp \left(\frac{-u\left(c_i\right)}{{\theta }^{\ast }}\right)}{\sum _j\exp \left(\frac{-u\left(c_j\right)}{{\theta }^{\ast }}\right)}u\left(c_i\right)=0$ numerically where ${\theta }^{\ast }$ solves $\sum _i{\pi }_i\frac{\exp \left(\frac{-u\left(c_i\right)}{{\theta }^{\ast }}\right)}{\sum _j\exp \left(\frac{-u\left(c_j\right)}{{\theta }^{\ast }}\right)}\log \left(\frac{\exp \left(\frac{-u\left(c_i\right)}{{\theta }^{\ast }}\right)}{\sum _j\exp \left(\frac{-u\left(c_j\right)}{{\theta }^{\ast }}\right)}\right)-\eta =0$ numerically.

Remark: It seems that the constraint problem is hard to solve in its original form, i.e. by finding the distorting measure that minimizes the expected utility.

It seems that viewing equation (25.7) as a root finding problem works much better.

But notice that equation (25.7) does not always have a solution.

Under $u=\log$, $c_1=c_2=1$, we have:

Conjecture: when our numerical method fails it because the derivative of the objective doesn’t exist for our choice of parameters.

Remark: It is tricky to get the algorithm to work properly for all values of $c_1$. In particular, parameters were chosen with graduate student descent.