Resolver Kaplan y Menzio: el tiempo de las compras

Question

Kaplan y Menzio modelo de tiempo de compra es un modelo de desempleo de búsqueda y emparejamiento en el que, para un equilibrio de estado estacionario, necesitamos determinar a variables:

• $J$ : Valor de un trabajador
• $u$ : tasa de desempleo

Su estado estable valores ( $\dot J, \dot u = 0$ ) vienen dadas por el siguiente sistema de ecuaciones:

$$ J = \frac{(1-\gamma)(S(u) + y_e - y_u)}{\rho + \delta}\\ u = \frac{\delta}{\delta + \lambda(J)} $$

Además, los "beneficios del bien con dispersión de precios" y los salarios, respectivamente, vienen dados por (ecuaciones (6), (7) de la página 12)

$$ S(u) = A(u) + B(u)*w(u)\\ w(u) = y_u + \gamma*(S(u) + y_e - y_u) $$

Dónde $A(u), B(u)$ son algunos marcadores de posición para un montón de constantes y parámetros, que pueden depender de $u$ . Yo saco los sueldos y resuelvo como

$$ \tilde S(u) = \frac{A(u) + B(u)(y_u + \gamma(y_e - y_u)}{1 - B(u)\gamma} $$

Entonces, utilizando la calibración de los autores y esta versión de $\tilde S(u)$ Puedo resolver ambos $J$ y $u$ . Aquí está:

Dada su calibración, obtienen dos interesantes equilibrios de estado estacionario en el $(u, J)$ espacio: $(0.053, 11.3)$ y $(0.081, 9.5)$ . Mi $u(J)$ El gráfico parece ser correcto ya que pasa por estos dos loci. El $J(u)$ línea, sin embargo, parece ser "demasiado pequeña" dado $u$ .

El único objeto algo difícil de calcular es $S(u)$ . He comprobado que mi paso de reemplazar realmente funciona: He calculado $w(u)$ utilizando $\tilde S(u)$ y verificó que $S(u, w(u)) == \tilde S(u)$ (hasta una aproximación numérica).

No pido que alguien encuentre mi error, sino dónde buscarlo: He comprobado todo lo que se me ha ocurrido y estoy algo atascado. Para los interesados, aquí está mi código Python:

# solves simple shopping time model
# only on the steady state equilibria

import numpy as np
import matplotlib.pyplot as plt

# all parameters for monthly
class Parameters(object):
    def __init__(self):

        self.psi_u = 0.27 # search twice, unemployed
        self.psi_e = 0.02 # search twice, employed < psi_u
        self.gamma = 0.74 # bargaining power
        self.alpha = 1 # BJ exponent in utility

        self.r = 15.7 # reservation price, home transformation
        self.c = 1 # production technology firm

        self.y_u = 4.91 # efficiency home
        self.y_e = 1 # efficiency firm

        self.rho = 0.003 # depreciation rate
        self.delta = 0.024 # separation rate

        self.phi = 1.24 # matching function efficiency
        self.k = 8.02 # search costs of labor for firm

def b(u, Param):
    return 1 + Param.psi_e + u*(Param.psi_u - Param.psi_e)
def s(u, Param):
    return 1 - u
def sigma(u, Param):
    return s(u, Param)/b(u, Param)
# seller meets buyer
def muOfU(u, Param):
    return np.minimum(1/sigma(u, Param), 1)
# buyer meets seller
def nuOfU(u, Param):
    return np.minimum(sigma(u, Param), 1)

def lambdaOfJ(J, Param):
    result = ( ((J/Param.k)**(Param.phi) - 1 )**(-1) + 1 )**(-float(1)/Param.phi)
    result[np.isnan(result)] = 0
    return result

# not needed atm, replaced within lambdaOfJ (instead of lambdaOfTheta)
def thetaOfJ(J, Param):
    #eta(theta)J = k
    #etaInverse = (eta^(-phi) - 1)^(1/phi)
    x = Param.k/J
    return (x**(-Param.phi) - 1)**(1/Param.phi)

def STilde(u, Param):

    A1 = muOfU(u, Param)*u*(1+Param.psi_u)/b(u, Param)
    A2 = 1 - 2*Param.psi_u*nuOfU(u, Param)/(1+Param.psi_u)
    A3 = Param.alpha*Param.y_u*(Param.r-Param.c)/Param.r
    A = A1*A2*A3

    B1 = muOfU(u, Param)*(1-u)*(1+Param.psi_e)/b(u, Param)
    B2 = 1 - 2*Param.psi_e*nuOfU(u, Param)/(1+Param.psi_e)
    B3 = Param.alpha*(Param.r-Param.c)/Param.r

    B = B1*B2*B3

    result = (A + B*(Param.y_u + Param.gamma*(Param.y_e - Param.y_u) ))/(1 - B*Param.gamma)
    return result

def S(u, wages, Param):
    A1 = muOfU(u, Param)*u*(1+Param.psi_u)/b(u, Param)
    A2 = 1 - 2*Param.psi_u*nuOfU(u, Param)/(1+Param.psi_u)
    A3 = Param.alpha*Param.y_u*(Param.r-Param.c)/Param.r
    A = A1*A2*A3

    B1 = muOfU(u, Param)*(1-u)*(1+Param.psi_e)/b(u, Param)
    B2 = 1 - 2*Param.psi_e*nuOfU(u, Param)/(1+Param.psi_e)
    B3 = Param.alpha*(Param.r-Param.c)/Param.r

    B = B1*B2*B3

    result = A + B*wages
    return result

def w(u, Param):
    return Param.y_u + Param.gamma*(STilde(u, Param) + Param.y_e - Param.y_u)

#result2 = A + B*w(u, Param)

def JSteadyState(u, Param):

    A = (1-Param.gamma)*(STilde(u, Param) + Param.y_e - Param.y_u )
    B = Param.rho + Param.delta
    return A/B

def uSteadyState(J, Param):

    B = Param.delta + lambdaOfJ(J, Param)
    return Param.delta/B

Param = Parameters()

# compute J(u) and u(J)
uGrid = np.linspace(0.001, 0.2, 100)
J = JSteadyState(uGrid, Param)

JGrid = np.linspace(5, 20, 1000)
u = uSteadyState(JGrid, Param)

# verify computation of S(u)
# wages given STilde:
wages = w(uGrid, Param)
# S given u, STilde
SOriginal = S(uGrid, wages, Param)
SWithTilde = STilde(uGrid, Param)

print max(abs(SWithTilde - SOriginal)) # 8.881784197e-16

# plot J(u) and u(J)
plt.plot(u, JGrid, label='u(J)')
plt.plot(uGrid, J, label='J(u)')
plt.legend()
plt.xlabel('u')
plt.ylabel('J')
plt.show()

Answer 1

ACTUALIZACIÓN
Tras una comunicación por correo electrónico con uno de los autores, G.W.Kaplan, he recalibrado el valor del parámetro del coste de publicación de vacantes $k$ para obtener un cruce de las dos líneas nulas para $u=0.05$ . Esto se consigue para $k=7.41$ (redondeado). Además, con este valor de $k$ Obtengo un segundo (pero no un tercer) estado estacionario. Un diagrama de cerca :

Esto todavía no es lo que muestran las figuras 1 y 2 del documento. La forma del $J$ -La inclinación nula sigue siendo el problema. Debería tener una parte cóncava inicial y luego una parte convexa para darnos tres estados estables. Pero no voy a profundizar más que eso.

---

El $u$ -Nullcline

En la página 8 los autores definen $\lambda(\theta) \equiv M(1,\theta)$ (Creo que deberían haber escrito para mayor claridad, $\lambda(\theta) \equiv M/u = M(1,\theta)$ ) . En la página 25 especifican la función de concordancia como $M(u,v) = uv(u^\phi + v^\phi)^{-1/\phi}$ . Por lo tanto, tenemos

$$\lambda(\theta) = \theta(1 + \theta^\phi)^{-1/\phi}$$

Esto significa que siempre que $\theta = 0 \implies \lambda(\theta) =0$ .

En la página 14, la ec. $(8)$ el dar $k> J \implies \theta = 0$ . En la etapa de calibración, $k=8.02$ . El $u$ -se define como

$$u_{SS} = \frac {\delta}{\delta + \lambda[\theta(J))]}$$

Todo ello implica que $$J < 8.02 \implies u_{SS} = 1$$

Utilizando las otras relaciones especificadas, tras un poco de álgebra, obtenemos $$J>k=8.02 \implies \lambda[\theta(J)] = \left(1-(k/J)^{\phi}\right)^{1/\phi}$$

que es efectivamente su código, un poco menos enrevesado. Y efectivamente el $u$ -la línea nula nunca se cruza con la $J$ -nullcline. Para los valores de $u$ cerca de la unidad, véase más abajo. Para valores bajos de $u$ obtenemos

\begin{array}{| r | r |} \hline \hline \text {u} & \text {Jss} & \text{uSS(in J units)} \\ \hline 0.03 & 12.25 & 23.06 \\ 0.04 & 11.53 & 14.13 \\ 0.05 & 10.86 & 11.75 \\ 0.06 & 10.23 & 10.66 \\ 0.07 & 9.64 & 10.03\\ 0.08 & 9.09 & 9.62\\ 0.09 & 8.57 & 9.34\\ 0.10 & 8.09 & 9.14\\ \hline \end{array}

El $u$ -la línea nula se mantiene siempre por encima de la $J$ -Nullcline. También he "empujado" el $J$ -nullcline por el factor $(1+\rho)$ es decir, la versión discreta de la ecuación. Pero $\rho=0.003$ El margen de beneficio es demasiado pequeño, por lo que de nuevo no hubo cruce. Por lo tanto, parece que lo que se incluyó en las simulaciones de los autores es, en algún punto, diferente de lo que nos dan las ecuaciones y los parámetros calibrados (Tabla 2) que aparecen en el documento. O bien, nos estamos perdiendo algo.

El $J$ -Nullcline
He comprobado el código del OP línea por línea, incluyendo los valores de los parámetros calibrados. No encontré ninguna discrpeancia con lo que da el documento. A continuación, copié y pegué el código para el $J$ -nullcline en Gretl, ajustándolo sólo para que coincida con el idioma local. Una nota: la forma en que se definen las distintas magnitudes en el documento, tenemos

$$\psi_u > \psi_e \implies b >1 \;\forall u \implies \sigma = s/b < 1, \;\forall u$$

$$\implies \text {muOfU}\equiv \mu(\sigma(u)) = \min(1/\sigma, 1) = 1,\; \forall u$$

$$\implies \text {nuOfU}\equiv \nu(\sigma(u)) = \min(\sigma, 1) = \sigma, \; \forall u$$

**GRETL script**  
solves simple shopping time model
 only on the steady state equilibria
     nulldata 100  
      genr series u = index/100   
        genr scalar  psi_u = 0.27 # search twice, unemployed
        genr scalar  psi_e = 0.02 # search twice, employed < psi_u
        genr scalar  gamma = 0.74 # bargaining power
        genr scalar  alpha = 1 # BJ exponent in utility

        genr scalar  r = 15.7 # reservation price, home transformation
        genr scalar  c = 1 # production technology firm

        genr scalar  y_u = 4.91 # efficiency home
        genr scalar  y_e = 1 # efficiency firm

        genr scalar  rho = 0.003 # depreciation rate
        genr scalar  delta = 0.024 # separation rate

        genr scalar  phi = 1.24 # matching function efficiency
        genr scalar  k = 8.02 # search costs of labor for firm

        genr series b =1 + psi_e + u*(psi_u - psi_e)
        genr series s = 1-u 
        genr series sigma = s/b
        genr series sigmareci = 1/sigma
        genr list  mlist = sigmareci const
        genr list  nlist  = sigma const
        genr series muOfU = min(mlist)  # seller meets buyer
        genr series nuOfU = min(nlist)  # buyer meets seller

# def STilde:

    genr series A1 = muOfU*u*(1+psi_u)/b
    genr series A2 = 1 - 2*psi_u*nuOfU/(1+psi_u)
    genr scalar A3 = alpha*y_u*(r-c)/r
    genr series A = A1*A2*A3

    genr series B1 = muOfU*(1-u)*(1+psi_e)/b
    genr series B2 = 1 - 2*psi_e*nuOfU/(1+psi_e)
    genr series B3 = alpha*(r-c)/r

    genr series  B = B1*B2*B3

    genr series STilde = (A + B*(y_u + gamma*(y_e - y_u) ))/(1 - B*gamma)

# def JSS

genr series JSS = (1-gamma)*(STilde + y_e - y_u ) / (rho+delta)

He obtenido los valores

y el gráfico

De lo anterior se desprende que el $J$ -nullcline, aunque empieza a aumentar, nunca se acerca de nuevo al valor $8$ que es $\approx$ la asíntota baja para el $u$ -nullcline.

Answer 2

Es posible que este problema se deba a los límites de la precisión de las operaciones de cálculo. El paquete Python bigfloat puede ser de interés para descartar esto.