Tributación Optima Solución Ramsey

2015-02-24 11:36

Contenido

Imposición óptima

Descripción ¶

Esta entrada estudia la política fiscal óptima en un entorno lineal cuadrático

Modificamos ligeramente un modelo conocido modelo de Robert Lucas y Nancy Stokey [LS83] por lo que las fórmulas convenientes para la resolución de los modelos lineales de segundo grado pueden aplicarse al simplificar los cálculos

La economía consiste en un hogar representativo y un gobierno benevolente

El gobierno financia un flujo exógeno de licitaciones de los préstamos contingentes al estado y un impuesto lineal sobre la renta del trabajo

Un impuesto lineal es a veces llamado un impuesto a tanto alzado

El hogar maximiza la utilidad eligiendo caminos para el consumo y el trabajo, que toman los precios y la tasa de impuestos del gobierno y los planes de endeudamiento cuando se dan

La utilidad alcanzable máxima para el hogar depende de los planes fiscales y de endeudamiento del gobierno

El problema de Ramsey [Ram27] es elegir los planes fiscales y de endeudamiento que maximicen el bienestar de la familia, teniendo un comportamiento optimizador de los hogares

Hay un gran número de equilibrios competitivos indexado por políticas fiscales diferentes del gobierno

El planificador de Ramsey elige el mejor equilibrio competitivo

Queremos estudiar la dinámica de las tasas de impuestos, los ingresos fiscales, la deuda del gobierno bajo un plan de Ramsey

Debido a que el modelo de Lucas y Stokey cuenta con deuda pública contingente al estado, la dinámica de la deuda pública difieren sustancialmente de las de un modelo de Robert Barro [Bar79]

El tratamiento que se da aquí sigue de cerca este manuscrito , elaborado por Thomas J. Sargent y Francois R. Velde

Cubrimos sólo las características clave de un problema y dejamos los resultados para la interpretación del interesado

Características Modelo ¶

Modelo cuadrático lineal (LQ)
Hogar Representante
Programación dinámica estocástica en un horizonte infinito
Impuestos distorsivos

El Problema de Ramsey ¶

Comenzamos describiendo las premisas clave en relación con la tecnología, los hogares y el sector gubernamental

Tecnología ¶

Trabajo se puede convertir uno por uno en una sola, no almacenable bien de consumo

En el habitual espíritu del modelo LQ, la cantidad de trabajo ofrecida en cada período es sin restricciones

Esto no es realista, pero útil cuando se trata de resolver el modelo

La oferta de trabajo realista puede ser inducida por valores de los parámetros adecuados

Los hogares ¶

Considere la posibilidad de un hogar representativo que elige un camino $\{\ell_t, c_t\}$ de mano de obra y consumo para maximizar

(1)

- E 1 2 Σ t = 0 \infty β t [(c t - b t) 2 + ℓ 2 t]

$- \mathbb E \frac{1}{2} \sum_{t=0}^{\infty} \beta^t \left[ (c_t - b_t)^2 + \ell_t^2 \right]$

sujeto a la restricción presupuestaria

(2)

E Σ t = 0 \infty β t p 0 t [d t + (1 - τ t) ℓ t + s t - c t] = 0

$\mathbb E \sum_{t=0}^{\infty} \beta^t p^0_t \left[ d_t + (1 - \tau_t) \ell_t + s_t - c_t \right] = 0$

Aquí

$\beta$ es un factor de descuento en $(0, 1)$
$p_t^0$ es el precio del estado en el tiempo $t$
$b_t$ es un parámetro de preferencia estocástico
$d_t$ es un proceso de dotación
$\tau_t$ es un impuesto único sobre las rentas del trabajo
$s_t$ es un prometido de tiempo $t$ con pago de cupón de la deuda emitida por el gobierno

La restricción presupuestaria requiere que el valor presente del consumo se limite al valor actual de las dotaciones, las rentas del trabajo y el pago de cupones en la tenencia de bonos

Gobierno ¶

El gobierno impone un impuesto lineal sobre la renta del trabajo, comprometiéndose plenamente a una trayectoria estocástica de las tasas de impuestos a tiempo cero

Asimismo, el gobierno emite deuda contingente al estado

Dados los impuestos del gobierno y los planes de endeudamiento, podemos construir un equilibrio competitivo mediante distorsion de los impuestos del gobierno

Entre todos esos equilibrios competitivos, el plan de Ramsey es el que maximiza el bienestar del consumidor representativo

Las variables exógenas ¶

Dotaciones, el gasto público, el parámetro de preferencia $b_t$ y el pago de cupones prometidos de la deuda pública inicial $s_t$ son todos exógenos, y dado por

$d_t = S_d x_t$
$g_t = S_g x_t$
$b_t = S_b x_t$
$s_t = S_s x_t$

Las matrices $S_d, S_g, S_b, S_s$ son primitivas y $\{x_t\}$ es un proceso estocástico exógeno tomando valores en $\mathbb R^k$

Consideramos dos especificaciones para $\{x_t\}$

Caso discreto: $\{x_t\}$ es un estado discreto cadena de Markov con matriz de transición $P$
Caso VAR: $\{x_t\}$ obedece $x_{t+1} = A x_t + C w_{t+1}$ donde $\{w_t\}$ es decir cero independiente de Gauss con identificar matriz de covarianza

Viabilidad ¶

La restricción periodo a periodo de viabilidad de esta economía es

(3)

c t + g t = d t + ℓ t

$c_t + g_t = d_t + \ell_t$

Un proceso en el consumo de mano de obra $\{\ell_t, c_t\}$ se llama factible si (3) que se cumple para todos $t$

La restricción presupuestaria del gobierno ¶

Donde $p_t^0$ es un precio de Arrow-Debreu escala, el tiempo de restricción presupuestaria del gobierno es cero

(4)

E Σ t = 0 \infty β t p 0 t (s t + g t - τ t ℓ t) = 0

$\mathbb E \sum_{t=0}^{\infty} \beta^t p^0_t (s_t + g_t - \tau_t \ell_t ) = 0$

Equilibrio ¶

Un equilibrio es una asignación factible $\{\ell_t, c_t\}$ , Una secuencia de precios $\{p_t\}$ y un sistema fiscal $\{\tau_t\}$ de tal manera que

La asignación $\{\ell_t, c_t\}$ es óptimo para el hogar determinado $\{p_t\}$ y $\{\tau_t\}$
La restricción presupuestaria del gobierno (4) está satisfecha

El El problema de Ramsey es elegir el equilibrio $\{\ell_t, c_t, \tau_t, p_t\}$ que maximiza el bienestar del hogar

Si $\{\ell_t, c_t, \tau_t, p_t\}$ es una solución al problema de Ramsey, entonces $\{\tau_t\}$ que se llama el Plan de Ramsey

El procedimiento de solución que adoptamos es

Utilice las condiciones de primer orden del problema en su casa de precisar los precios y las asignaciones dadas $\{\tau_t\}$
Utilice estas expresiones para reescribir la restricción presupuestaria del gobierno (4) en términos de variables exógenas y las asignaciones
Maximizar la función objetivo del hogar (1) sujeto a la restricción de la última etapa y la restricción de factibilidad (3)

La solución a este problema de maximización deja abajo todas las cantidades de interés

Solución ¶

El primer paso es obtener las condiciones de primer orden para el problema de la unidad familiar, tomando los impuestos y los precios como dados

Dejando $\mu$ ser el multiplicador de Lagrange en (2) , las condiciones de primer orden son $p_t = (c_t - b_t) / \mu$ y $\ell_t = (c_t - b_t) (1 - \tau_t)$

Reorganizar y normalizando en $\mu = b_0 - c_0$ , Podemos escribir estas condiciones como

(5)

p t = b t - c t b 0 - c 0 y τ t = 1 - ℓ t b t - c t

$p_t = \frac{b_t - c_t}{b_0 - c_0} \quad \text{and} \quad \tau_t = 1 - \frac{\ell_t}{b_t - c_t}$

Sustituyendo (5) en la restricción presupuestaria del gobierno (4) rendimientos

(6)

E Σ t = 0 \infty β t [(b t - c t) (s t + g t - ℓ t) + ℓ 2 t] = 0

$\mathbb E \sum_{t=0}^{\infty} \beta^t \left[ (b_t - c_t)(s_t + g_t - \ell_t) + \ell_t^2 \right] = 0$

El problema de Ramsey ahora consiste en maximizar (1) sujeto a (6) y (3)

El lagrangiano asociado es

(7)

L = E Σ t = 0 \infty β t {- 1 2 [(c t - b t) 2 + ℓ 2 t] + λ [(b t - c t) (ℓ t - s t - g t) - ℓ 2 t] + μ t [d t + ℓ t - c t - g t]}

$\mathscr L = \mathbb E \sum_{t=0}^{\infty} \beta^t \left\{ - \frac{1}{2} \left[ (c_t - b_t)^2 + \ell_t^2 \right] + \lambda \left[ (b_t - c_t)(\ell_t - s_t - g_t) - \ell_t^2 \right] + \mu_t [d_t + \ell_t - c_t - g_t] \right\}$

Las condiciones de primer orden asociadas a $c_t$ y $\ell_t$ son

- (c t - b t) + λ [- ℓ t + (g t + s t)] = μ t

$- (c_t - b_t ) + \lambda [- \ell_t + (g_t + s_t )] = \mu_t$

ℓ t - λ [(b t - c t) - 2 ℓ t] = μ t

$\ell_t - \lambda [(b_t - c_t) - 2 \ell_t ] = \mu_t$

La combinación de estas dos últimas igualdades con (3) y el trabajo a través de la álgebra, se puede demostrar que

(8)

ℓ t = ℓ ¯ t - ν m t y c t = c ¯ t - ν m t

$\ell_t = \bar \ell_t - \nu m_t \quad \text{and} \quad c_t = \bar c_t - \nu m_t$

donde

$\nu := \lambda / (1 + 2 \lambda)$
$\bar \ell_t := (b_t - d_t + g_t) / 2$
$\bar c_t := (b_t + d_t - g_t) / 2$
$m_t := (b_t - d_t - s_t ) / 2$

Aparte de $\nu$ , Todas estas cantidades se expresan en términos de variables exógenas

Para resolver $\nu$ , Podemos utilizar la restricción presupuestaria del gobierno de nuevo

El término dentro de los corchetes en (6) es $(b_t - c_t)(s_t + g_t) - (b_t - c_t) \ell_t + \ell_t^2$

Uso de (8) , las definiciones anteriores y el hecho de que $\bar \ell = b - \bar c$ , Este término se puede reescribir como

(b t - c ¯ t) (g t + s t) + 2 m 2 t (ν 2 - ν)

$(b_t - \bar c_t) (g_t + s_t ) + 2 m_t^2 ( \nu^2 - \nu)$

Volver a insertar en (6) , obtenemos

(9)

E {Σ t = 0 \infty β t (b t - c ¯ t) (g t + s t)} + (ν 2 - ν) E {Σ t = 0 \infty β t 2 m 2 t} = 0

$\mathbb E \left\{ \sum_{t=0}^{\infty} \beta^t (b_t - \bar c_t) (g_t + s_t ) \right\} + ( \nu^2 - \nu) \mathbb E \left\{ \sum_{t=0}^{\infty} \beta^t 2 m_t^2 \right\} = 0$

Aunque puede que no sea clara, sin embargo, casi hemos llegado:

Los dos expectativas términos en (9) se pueden resolver en términos de primitivas modelo
Esto a su vez nos permite resolver para el multiplicador de Lagrange $\nu$
Con $\nu$ en la mano, podemos volver atrás y resolver las asignaciones a través de (8)
Una vez que tenemos las asignaciones, los precios y el sistema tributario se puede derivar de (5)

Resolver el término cuadrático ¶

Vamos a considerar cómo obtener el término $\nu$ en (9)

Si somos capaces de resolver las dos sumas esperados

(10)

b 0 : = E {Σ t = 0 \infty β t (b t - c ¯ t) (g t + s t)} y un 0 : = E {Σ t = 0 \infty β t 2 m 2 t}

$b_0 := \mathbb E \left\{ \sum_{t=0}^{\infty} \beta^t (b_t - \bar c_t) (g_t + s_t ) \right\} \quad \text{and} \quad a_0 := \mathbb E \left\{ \sum_{t=0}^{\infty} \beta^t 2 m_t^2 \right\}$

entonces el problema se reduce a resolver

b 0 + una 0 (ν 2 - ν) = 0

$b_0 + a_0 (\nu^2 - \nu) = 0$

para $\nu$

A condición de que $4 b_0 < a_0$ , Hay una solución única $\nu \in (0, 1/2)$ Y un único correspondiente $\lambda > 0$

Vamos a encontrar la manera de resolver los términos de expectativas en (10)

Para el primero, la variable aleatoria $(b_t - \bar c_t) (g_t + s_t )$ dentro de la suma se puede expresar como

1 2 x' t (S b - S d + S g)' (S g + S s) x t

$\frac{1}{2} x_t' (S_b - S_d + S_g)' (S_g + S_s) x_t$

Para el segundo expectativa en (10) , la variable aleatoria $2 m_t^2$ puede ser escrito como

1 2 x' t (S b - S d - S s)' (S b - S d - S s) x t

$\frac{1}{2} x_t' (S_b - S_d - S_s)' (S_b - S_d - S_s) x_t$

Se deduce que ambas de estas expectativas términos son casos especiales de la expresión

(11)

q (x 0) = E Σ t = 0 \infty β t x' t H x t

$q(x_0) = \mathbb E \sum_{t=0}^{\infty} \beta^t x_t' H x_t$

donde $H$ es una matriz conformable, y $x_t'$ es la transpuesta de vector columna $x_t$

Supongamos primero que $\{x_t\}$ es la gaussiana VAR describe anteriormente

En este caso, la fórmula para calcular $q(x_0)$ se sabe que es $q(x_0) = x_0' Q x_0 + v$ , Donde

$Q$ es la solución a $Q = H + \beta A' Q A$ Y
$v = \text{trace} \, (C' Q C) \beta / (1 - \beta)$

La primera ecuación se conoce como una ecuación de Lyapunov discreta, y se puede resolver utilizando esta función

Siguiente suponer que $\{x_t\}$ es el proceso de Markov descrito anteriormente

Supongamos además que cada $x_t$ toma valores en el espacio de estados $\{x^1, \ldots, x^N\} \subset \mathbb R^k$

Dejar $h \colon \mathbb R^k \to \mathbb R$ ser una función dada, y supongamos que deseamos para evaluar

q (x 0) = E Σ t = 0 \infty β t h (x t) dada x 0 = x j

$q(x_0) = \mathbb E \sum_{t=0}^{\infty} \beta^t h(x_t) \quad \text{given} \quad x_0 = x^j$

Por ejemplo, en la discusión anterior, $h(x_t) = x_t' H x_t$

Es legítimo que pasar la expectativa a través de la suma, lo que lleva a

(12)

q (x 0) = Σ t = 0 \infty β t (P t h) [j]

$q(x_0) = \sum_{t=0}^{\infty} \beta^t (P^t h)[j]$

Aquí

$P^t$ es el $t$ poder-ésima de la matriz de transición $P$
$h$ es decir, con algún abuso de notación, el vector $(h(x^1), \ldots, h(x^N))$
$(P^t h)[j]$ indica la $j$ elemento -th de $P^t h$

Puede ser muestran que (12) es de hecho igual a la $j$ -ésimo elemento del vector $(I - \beta P)^{-1} h$

Este último hecho se aplica en los cálculos siguientes

Otras variables ¶

Estamos interesados en el seguimiento de varias otras variables además de los descritos anteriormente

Uno de ellos es el valor presente de las obligaciones del gobierno en circulación al momento $t$ , Que se puede expresar como

(13)

B t : = E t Σ j = 0 \infty β j p t t + j (τ t + j ℓ t + j - g t + j)

$B_t := \mathbb E_t \sum_{j=0}^{\infty} \beta^j p^t_{t+j} (\tau_{t+j} \ell_{t+j} - g_{t+j})$

Usando nuestra expresión de los precios y el plan de Ramsey, también puede escribir $B_t$ como

B t = E t Σ j = 0 \infty β j ( b t + j - c t + j ) ( ℓ t + j - g t + j ) - ℓ 2 t + j b t - c t

$B_t = \mathbb E_t \sum_{j=0}^{\infty} \beta^j \frac{ (b_{t+j} - c_{t+j})(\ell_{t+j} - g_{t+j}) - \ell^2_{t+j} } { b_t - c_t }$

Esta variación es más conveniente para la computación

Sin embargo, otra manera de escribir $B_t$ es

B t = Σ j = 0 \infty R - 1 t j (τ t + j ℓ t + j - g t + j)

$B_t = \sum_{j=0}^{\infty} R^{-1}_{tj} (\tau_{t+j} \ell_{t+j} - g_{t+j})$

donde

R - 1 t j : = E t β j p t t + j

$R^{-1}_{tj} := \mathbb E_t \beta^j p^t_{t+j}$

Aquí $R_{tj}$ puede ser considerado como el bruto $j$ tasa libre de riesgo -periodo en la celebración de la deuda pública entre $t$ y $j$

Además, dejando $R_t$ ser la tasa libre de riesgo de un período, definimos

π t + 1 : = B t + 1 - R t [B t - (τ t ℓ t - g t)]

$\pi_{t+1} := B_{t+1} - R_t [B_t - (\tau_t \ell_t - g_t)]$

Π t : = Σ s = 0 t π t

$\Pi_t := \sum_{s=0}^t \pi_t$

El término $\pi_{t+1}$ es el pago de la cartera del público de la deuda pública

Si distorsionamos probabilidades de transición de paso por el factor de ajuste

ξ t : = p t t + 1 E t p t t + 1

$\xi_t := \frac{p^t_{t+1}}{ \mathbb E_t p^t_{t+1} }$

entonces $\Pi_t$ es una martingala bajo las probabilidades distorsionadas

Vamos a ocuparnos del cómputo

Aplicación ¶

El siguiente código proporciona funciones para

Resolviendo para el plan de Ramsey dada una especificación de la economía
La simulación de la dinámica de las principales variables

El archivo es casos / lqramsey.py desde el repositorio principal

Descripción y aclaraciones se dan a continuación

"" " 
Nombre de archivo: lqramsey.py 
Autores: Thomas Sargent, Doc-Jin Jang, Jeong-hun Choi, John Stachurski

Este módulo proporciona código para calcular equilibrios Ramsey en una economía LQ con 
los impuestos distorsivos. El programa calcula las asignaciones (consumo, 
ocio), las tasas de impuestos, los ingresos, el valor presente neto de la deuda y otras 
cantidades relacionadas.

Funciones para trazar los resultados también se proporcionan a continuación.

Ver la conferencia en https://quant-econ.net/lqramsey.html para una descripción de 
la modelo.

"" "

import  sys 
import  numpy  as  np 
from  numpy  import  sqrt ,  eye ,  dot ,  zeros ,  cumsum 
from  numpy.random  import  randn 
import  scipy.linalg 
import  matplotlib.pyplot  as  plt 
from  collections  import  namedtuple 
from  quantecon  import  nullspace ,  mc_sample_path ,  var_quadratic_sum


# == Configurar una namedtuple para almacenar datos en el modelo de la economía == # 
Economía  =  namedtuple ( 'economía' ,  ( 'beta' ,  # Factor de descuento  'Mx' ,  # Gbno matriz selector de gasto  'SD' ,  # selector dotación exógena matriz  "Sb" ,  # Utilidad matriz selector de parámetros  'SS' ,  pagos # promocionales matriz selector  'discretas' ,  # discreta o continua - boolean  'proc' ))  parámetros de proceso # estocásticos

# == Configurar una namedtuple para almacenar valores de retorno para compute_paths () == # 
Sendero  =  namedtuple ( 'ruta' ,  ( 'g' ,  el gasto # Gob  'd' ,  # Dotación  'b' ,  # parámetro de cambio Utilidad  's ' ,  # cupón de pago de la deuda existente  'c' ,  # Consumo  'l' ,  # Trabajo  'p' ,  # Precio  'tau' ,  # Tipo impositivo  'rvn' ,  # Ingresos  'B' ,  # Gbno deuda  'R' ,  # Riesgo retorno bruto libre  'pi' ,  # tasa de interés libre de riesgo de un período de  'Pi' ,  # tasa acumulativa de retorno, ajustado  'xi' ))  # factor de ajuste para Pi


def  compute_paths ( T ,  econ ):  "" " 
 trayectorias temporales simuladas Calculadaspara las variables exógenas y endógenas.

 Parámetros 
 =========== 
 T: int 
 Longitud de la simulación

 econ: un registro del tipo 'Economía', que contiene 
 beta - Factor de Descuento 
 Mx - Gobierno matriz selector de gasto 
 Sd - matriz selector dotación exógena 
 Sb - Utilidad de matriz selector de parámetros 
 Ss - Los pagos de cupones de la matriz de selección 
 discreto - proceso exógeno discreto (Verdadero o Falso) 
 proc - parámetros de proceso estocástico

 Devoluciones 
 ======== 
 camino: un namedtuple del tipo 'Camino', que contiene 
 g - Gobierno invierte 
 d - Dotación 
 b - Utilidad parámetro de desplazamiento 
 s - pago de cupón de la deuda existente 
 c - Consumo 
 l - Trabajo 
 p - Precio 
 tau - Tipo impositivo 
 rvn - Ingresos 
 B - El Gobierno de la deuda 
 R - Riesgo retorno bruto libre 
 pi - Un período de tasa de interés libre de riesgo 
 Pi - tasa acumulativa de retorno, ajustado 
 xi - Factor de Ajuste por Pi

 Los valores correspondientes son ndarrays numpy planas.

 "" "
 # == Nombres Simplificar == #  beta ,  Mx ,  Sd ,  Sb ,  Ss  =  econ . beta ,  econ . Sg ,  econ . Sd ,  econ . Sb ,  econ . Ss
 si  econ . discreta :  P ,  x_vals  =  econ . proc  cosa :  A ,  C  =  econ . proc
 # == Simular el proceso exógeno x == #  si  econ . discreta :  estado  =  mc_sample_path ( P ,  init = 0 ,  SAMPLE_SIZE = T )  x  =  x_vals [:,  estado ]  otro :  # == Generar una condición x0 x0 satisfacer inicial = A x0 == #  nx ,  nx  =  A . forma  x0  =  espacio nulo (( ojo ( nx )  -  A ))  x0  =  - x0  si  ( x0 [ nx - 1 ]  <  0 )  otro  x0  x0  =  x0  /  x0 [ nx - 1 ]
 # == Generar una serie de tiempo x de longitud T a partir de x0 == #  nx ,  nw  =  C . shape  x  =  zeros (( nx ,  T ))  w  =  randn ( nw ,  T )  x [:,  0 ]  =  x0 . T  for  t  in  range ( 1 ,  T ):  x [:,  t ]  =  dot ( A ,  x [:,  t - 1 ])  +  dot ( C ,  w [:,  t ])
 # == Compute secuencias variables exógenas == #  g ,  d ,  b ,  s  =  ( dot ( S ,  x ) . aplanan ()  para  S  en  ( Mx ,  Sd ,  Sb ,  Ss ))
 # == Resuelve para multiplicadores de Lagrange en la restricción presupuestaria Gbno == #  # De hecho resolvemos para nu = lambda / (1 ​​+ 2 * lambda). Aquí nu es la  solución # para una ecuación cuadrática un (nu ** 2 - nu) + b = 0 donde  # ayb se espera sumas descontadas de formas cuadráticas del estado.  Sm  =  Sb  -  Sd  -  Ss  # == Calcula a y b ==                                                                            
 # == Prueba que nu tiene una solución real antes de asignar == #  warning_msg  =  "" " 
 Sugerencia:. es probable que establecer el gasto público también {} Elegir un {} 
 . Congreso y empezar de nuevo 
 "" "  disco  =  a0 ** 2  -  4  *  a0  *  b0  si  disco  > =  0 :  nu  =  0.5  *  ( a0  -  sqrt ( disco ))  /  a0  demás :  print ( ". No hay equilibrio Ramsey para estos parámetros" )  print ( warning_msg . formato ( "alto" ,  'republicano' ))  sys . de salida ( 0 )
 # == Prueba de que el multiplicador de Lagrange tiene el signo correcto == #  si  nu  *  ( 0,5  -  nu )  <  0 :  print ( ". multiplicador negativo en la restricción presupuestaria del gobierno" )  print ( warning_msg . formato ( 'bajo' ,  ' 'Democrática ))  sys . de salida ( 0 )
 # == Resuelva para el nu yx asignación dada ==                                          Precio sin normalización  tau  =  1  -  l  /  ( b  -  c )  rvn  =  l  *  tau
 # == Compute variables restantes == #  if  econ . discrete :  H  =  dot ( Sb  -  Sc ,  x_vals )  *  dot ( Sl  -  Sg ,  x_vals )  -  dot ( Sl ,  x_vals ) ** 2  temp  =  dot ( F ,  H . T ) . flatten ()  B  =  temp [ state ]  /  p  H  =  dot ( P [ state ,  :],  dot ( Sb  -  Sc ,  x_vals ) . T ) . flatten ()  R  =  p  /  ( beta  *  H )  temp  =  dot ( P [ state ,  :],  dot ( Sb  -  Sc ,  x_vals ) . T ) . flatten ()  xi  =  p [ 1 :]  /  temp [: T - 1 ]  else :  H  =  dot ( Sl . T ,  Sl )  -  dot (( Sb  -  Sc ) . T ,  Sl  -  Sg )  L  =  np . empty ( T )  for  t  in  range ( T ):  L [ t ]  =  var_quadratic_sum ( A ,  C ,  H ,  beta ,  x [:,  t ])  B  =  L  /  p  Rinv  =  ( beta  *  dot ( dot ( Sb  -  Sc ,  A ),  x )) . flatten ()  /  p  R  =  1  /  Rinv  AF1  =  dot ( Sb  -  Sc ,  x [:,  1 :])  AF2  =  dot ( dot ( Sb  -  Sc ,  A ),  x [:,  : T - 1 ])  xi  =  AF1  /  AF2  xi  =  xi . flatten ()
 pi  =  B [ 1 :]  -  R [: T - 1 ]  *  B [: T - 1 ]  -  rvn [: T - 1 ]  +  g [: T - 1 ]  Pi  =  cumSum ( pi  *  xi )
 # == Preparar valores de retorno == #  ruta  =  Camino ( g = g ,  d = d ,  b = b ,  s = s ,  c = c ,  l = l ,  p = p ,  tau = tau ,  rvn = rvn ,  B = B ,  R = R ,  pi = pi ,  pi = pi ,  xi = xi )
 retorno  camino


def  gen_fig_1 ( ruta ):  "" " 
 El parámetro es el namedtuple ruta devuelta por compute_paths (Ver). 
 la cadena de documentación de esa función para más detalles. 
 "" "
 T  =  len ( camino . c )
 # == == Preparar ejes #  num_rows ,  num_cols  =  2 ,  2  fig ,  axes  =  plt . subplots ( num_rows ,  num_cols ,  figsize = ( 14 ,  10 ))  plt . subplots_adjust ( hspace = 0.4 )  for  i  in  range ( num_rows ):  for  j  in  range ( num_cols ):  axes [ i ,  j ] . grid ()  axes [ i ,  j ] . set_xlabel ( r'Time' )  bbox  =  ( 0. ,  1.02 ,  1. ,  . 102 )  legend_args  =  { 'bbox_to_anchor' :  bbox ,  'loc' :  3 ,  'mode' :  'expand' }  p_args  =  { 'lw' :  2 ,  'alpha' :  0.7 }
 # == Consumo Plot, los gastos y los ingresos Gbno == #  ax  =  ejes [ 0 ,  0 ]  hacha . parcela ( camino . rvn ,  etiqueta = r '$ \ tau_t \ell_t$' ,  ** p_args )  ax . plot ( path . g ,  label = r'$g_t$' ,  ** p_args )  ax . plot ( path . c ,  label = r'$c_t$' ,  ** p_args )  ax . legend ( ncol = 3 ,  ** legend_args )
 # == Gasto gob Terreno y la deuda == #  ax  =  ejes [ 0 ,  1 ]  hacha . parcela ( lista ( rango ( 1 ,  T + 1 )),  camino . rvn ,  etiqueta = r '$ \ tau_t \ell_t$' ,  ** p_args )  ax . plot ( list ( range ( 1 ,  T + 1 )),  path . g ,  label = r'$g_t$' ,  ** p_args )  ax . plot ( list ( range ( 1 ,  T )),  path . B [ 1 : T ],  label = r'$B_{t+1}$' ,  ** p_args )  ax . legend ( ncol = 3 ,  ** legend_args )
 # == Retorno libre de riesgo Argumento == #  ax  =  ejes [ 1 ,  0 ]  hacha . parcela ( lista ( rango ( 1 ,  T + 1 )),  camino . R  -  1 ,  label = r '$ R_t - 1 $' ,  ** p_args )  hacha . leyenda ( ncol = 1 ,  ** legend_args )
 # == Ingresos Terreno, el gasto y la tasa libre de riesgo == #  ax  =  ejes [ 1 ,  1 ]  hacha . parcela ( lista ( rango ( 1 ,  T + 1 )),  camino . rvn ,  etiqueta = r '$ \ tau_t \ell_t$' ,  ** p_args )  ax . plot ( list ( range ( 1 ,  T + 1 )),  path . g ,  label = r'$g_t$' ,  ** p_args )  axes [ 1 ,  1 ] . plot ( list ( range ( 1 ,  T )),  path . pi ,  label = r'$\pi_{t+1}$' ,  ** p_args )  ax . legend ( ncol = 3 ,  ** legend_args )
 plt . mostrar ()


def  gen_fig_2 ( ruta ):  "" " 
 El parámetro es el namedtuple ruta devuelta por compute_paths (Ver). 
 la cadena de documentación de esa función para más detalles. 
 "" "
 T  =  len ( camino . c )
 # == == Preparar ejes #  num_rows ,  num_cols  =  2 ,  1  fig ,  axes  =  plt . subplots ( num_rows ,  num_cols ,  figsize = ( 10 ,  10 ))  plt . subplots_adjust ( hspace = 0.5 )  bbox  =  ( 0. ,  1.02 ,  1. ,  . 102 )  bbox  =  ( 0. ,  1.02 ,  1. ,  . 102 )  legend_args  =  { 'bbox_to_anchor' :  bbox ,  'loc' :  3 ,  'mode' :  'expand' }  p_args  =  { 'lw' :  2 ,  'alpha' :  0.7 }
 # == Factor de ajuste Argumento == #  ax  =  axes [ 0 ]  ax . plot ( list ( range ( 2 ,  T + 1 )),  path . xi ,  label = r'$\xi_t$' ,  ** p_args )  ax . grid ()  ax . set_xlabel ( r'Time' )  ax . legend ( ncol = 1 ,  ** legend_args )
 # == Argumento ajustado rentabilidad acumulada == #  ax  =  axes [ 1 ]  ax . plot ( list ( range ( 2 ,  T + 1 )),  path . Pi ,  label = r'$\Pi_t$' ,  ** p_args )  ax . grid ()  ax . set_xlabel ( r'Time' )  ax . legend ( ncol = 1 ,  ** legend_args )
 plt . mostrar ()

Comentarios sobre el Código ¶

La función var_quadratic_sum importado de quadsums es para calcular el valor de (11) cuando el proceso exógeno $\{ x_t \}$ es del tipo VAR descrito anteriormente

Por debajo de la definición de la función, podrás ver las definiciones de dos namedtuple objetos, Economía y Ruta

El primero se utiliza para recoger todos los parámetros y las primitivas de una economía LQ dado, mientras que el segundo recoge la salida de los cálculos

En Python, un namedtuple es un tipo de datos populares desde la colecciones módulo de la biblioteca estándar que replica la funcionalidad de una tupla, sino que también le permite asignar un nombre a cada elemento de la tupla

Estos elementos pueden ser entonces referencias través de la notación atributo de puntos - véase por ejemplo el uso de trayectoria en la función gen_fig_1 ()

Los beneficios de usar namedtuples :

Mantiene el contenido organizado por sentido
Ayuda a reducir el número de variables globales

Aparte de eso, nuestro código es largo pero relativamente sencillo

Ejemplos ¶

Veamos dos ejemplos de uso

El Caso Continuo ¶

Nuestro primer ejemplo adopta la especificación VAR descrito anteriormente

En cuanto a las primitivas, establecemos

$\beta = 1 / 1.05$
$b_t = 2.135$ y $s_t = d_t = 0$ para todos $t$

El gasto del gobierno evoluciona de acuerdo a

g t + 1 - μ g = ρ (g t - μ g) + C g w g, t + 1

$g_{t+1} - \mu_g = \rho (g_t - \mu_g) + C_g w_{g, t+1}$

con $\rho = 0.7$ , $\mu_g = 0.35$ y $C_g = \mu_g \sqrt{1 - \rho^2} / 10$

Aquí está el código, a partir de archivos de ejemplos / lqramsey_ar1.py

"" " 
Nombre de archivo: lqramsey_ar1.py 
Autores: Thomas Sargent, Doc-Jin Jang, Jeong-hun Choi, John Stachurski

Ejemplo 1: el gasto de Gobierno es AR (1) y el Estado es (g, 1).

"" "

importar  numpy  como  np 
de  numpy  importación  gama 
importación  lqramsey

# == == Parámetros # 
beta  =  1  /  1.05 
rho ,  mg  =  . 7 ,  . 35 
A  =  np . identity ( 2 ) 
A [ 0 ,  :]  =  rho ,  mg  *  ( 1 - rho ) 
C  =  np . zeros (( 2 ,  1 )) 
C [ 0 ,  0 ]  =  np . sqrt ( 1  -  rho ** 2 )  *  mg  /  10 
Sg  =  array (( 1 ,  0 )) . reshape ( 1 ,  2 ) 
Sd  =  array (( 0 ,  0 )) . reshape ( 1 ,  2 ) 
Sb  =  array (( 0 ,  2.135 )) . reshape ( 1 ,  2 ) 
Ss  =  array (( 0 ,  0 )) . reshape ( 1 ,  2 )

economía  =  lqramsey . Economía ( beta = beta ,  Sg = Sg ,  Sd = Sd ,  Sb = Sb ,  Ss = Ss ,  discreta = False ,  proc = ( A ,  C ))

T  =  50 
camino  =  lqramsey . compute_paths ( T ,  economía ) 
lqramsey . gen_fig_1 ( ruta )

Ejecutar el programa produce la figura

Las leyendas sobre las cifras indican las variables siendo rastreados

El más obvio de la figura es nivelación de los impuestos en el sentido de que los ingresos fiscales es mucho menos variable que el gasto público

Después de ejecutar el código anterior, si a continuación, ejecuta lqramsey.gen_fig_2 (camino) de su IPython pagar usted producirá la figura

La caso discreto ¶

Nuestro segundo ejemplo adopta una especificación de Markov para el proceso exógeno

Aquí está el código, a partir de archivos de ejemplos / lqramsey_discrete.py

"" " 
Nombre de archivo: lqramsey_discrete.py 
Autores: Thomas Sargent, Doc-Jin Jang, Jeong-hun Choi, John Stachurski

Modelo LQ Ramsey y los procesos exógenos discretos.

"" " 
de  numpy  importación  gama 
importación  lqramsey

# == == Parámetros # 
beta  =  1  /  1,05 
P  =  array ([[ 0.8 ,  0.2 ,  0.0 ],  [ 0.0 ,  0.5 ,  0.5 ],  [ 0.0 ,  0.0 ,  1.0 ]]) 
# == posibles estados del mundo == # 
# Cada columna es un estado del mundo. Las filas son [GDBS
                
       
       
       
       

economía  =  lqramsey . Economía ( beta = beta ,  Sg = Sg ,  Sd = Sd ,  Sb = Sb ,  Ss = Ss ,  discreta = Verdadero ,  proc = ( P ,  x_vals ))

T  =  15 
camino  =  lqramsey . compute_paths ( T ,  economía ) 
lqramsey . gen_fig_1 ( ruta )