32. 通货膨胀税的拉弗曲线#

32.1. 概述#

本讲座研究了通货膨胀税的静态和动态拉弗曲线，使用的是讲座通过货币资助的政府赤字和价格水平中研究的模型的非线性模型版本。

我们采用了[Cagan, 1956]在其经典论文中使用的对数线性货币需求函数，而不是讲座通过货币资助的政府赤字和价格水平中使用的线性需求函数。

这一改变需要我们修改部分分析。

特别是,我们的动态系统在状态变量上不再是线性的。

然而,基于我们所谓的”方法2”的经济逻辑分析仍然保持不变。

我们将发现与讲座通过货币资助的政府赤字和价格水平中研究的结果类似的定性结果。

该讲座展示了本讲座中模型的线性版本。

与那个讲座一样,我们讨论以下主题:

  • 政府通过印制纸币或电子货币征收的通货膨胀税

  • 通货膨胀税率中存在两个静态均衡的动态拉弗曲线

  • 在理性预期下的反常动态,系统趋向于较高的静态通货膨胀税率

  • 与该静态通货膨胀率相关的奇特的比较静态分析,它表明通货膨胀可以通过运行更高的政府赤字来降低

这些结果为分析拉弗曲线与自适应预期做准备,该讲座研究了本模型的一个版本,使用一种”适应性预期”而不是理性预期。

该讲座将展示:

  • 用适应性预期替代理性预期不改变两个静态通货膨胀率,但是\(\ldots\)

  • 它通过使系统通常收敛于较低的静态通货膨胀率来逆转反常动态

  • 现在通货膨胀可以通过运行较低的政府赤字来降低,从而出现了更合理的比较动态结果

32.2. 模型#

设:

  • \(m_t\) 为时间 \(t\) 初的货币供应量对数

  • \(p_t\) 为时间 \(t\) 的价格水平对数

货币需求函数为:

(32.1)#\[ m_{t+1} - p_t = -\alpha (p_{t+1} - p_t) \]

其中 \(\alpha \geq 0\)。

货币供应量的动态方程为:

(32.2)#\[ \exp(m_{t+1}) - \exp(m_t) = g \exp(p_t) \]

其中 \(g\) 是政府支出中通过印钞来融资的部分。

Remark 32.1

请注意,虽然方程(32.1)在货币供应量和价格水平的对数上是线性的,方程(32.2)在水平值上是线性的。这需要我们调整在讲座通过货币资助的政府赤字和价格水平中使用的均衡计算方法。

32.3. 通货膨胀率的极限#

我们可以通过研究稳态拉弗曲线来计算 \(\overline \pi\) 的两个可能极限值。

因此,在稳态中

\[ m_{t+1} - m_t = p_{t+1} - p_t = x \quad \forall t , \]

其中 \(x > 0\) 是货币供应量和价格水平的对数的共同增长率。

几行代数运算可以得出 \(x\) 满足的方程:

(32.3)#\[ \exp(-\alpha x) - \exp(-(1 + \alpha) x) = g \]

我们需要

(32.4)#\[ g \leq \max_{x \geq 0} \{\exp(-\alpha x) - \exp(-(1 + \alpha) x) \}, \]

这样通过印钞来融资才是可行的。

(32.3)的左侧是通过印钞筹集的稳态收入。

(32.3)的右侧是政府在时间 \(t\) 通过印钞筹集的商品数量。

稍后我们将绘制方程(32.3)的左右两侧。

但首先让我们编写代码来计算稳态 \(\overline \pi\)。

让我们先导入一些库

from collections import namedtuple
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
from scipy.optimize import fsolve 

FONTPATH = "fonts/SourceHanSerifSC-SemiBold.otf"
mpl.font_manager.fontManager.addfont(FONTPATH)
plt.rcParams['font.family'] = ['Source Han Serif SC']

让我们创建一个namedtuple来存储模型的参数

CaganLaffer = namedtuple('CaganLaffer', 
                        ["m0",  # t=0时货币供应量的对数
                         "α",   # 货币需求的灵敏度
                         "λ",
                         "g" ])

# 创建一个 凯根拉弗 模型 
def create_model(α=0.5, m0=np.log(100), g=0.35):
    return CaganLaffer(α=α, m0=m0, λ=α/(1+α), g=g)

model = create_model()

现在我们编写计算稳态\(\overline \pi\)的代码。

# 定义π_bar的公式
def solve_π(x, α, g):
    return np.exp(-α * x) - np.exp(-(1 + α) * x) - g

def solve_π_bar(model, x0):
    π_bar = fsolve(solve_π, x0=x0, xtol=1e-10, args=(model.α, model.g))[0]
    return π_bar

# 求解两个稳态的π
π_l = solve_π_bar(model, x0=0.6)
π_u = solve_π_bar(model, x0=3.0)
print(f'两个稳态的π是: {π_l, π_u}')

两个稳态的π是: (np.float64(0.6737147075333034), np.float64(1.6930797322614815))

我们找到两个稳态\(\overline \pi\)的值。

32.4. 稳态拉弗曲线#

以下图形展示了稳态拉弗曲线以及两个稳态通货膨胀率。

def compute_seign(x, α):
    return np.exp(-α * x) - np.exp(-(1 + α) * x)

def plot_laffer(model, πs):
    α, g = model.α, model.g
    
    # 生成 π 值
    x_values = np.linspace(0, 5, 1000)

    # 计算对应的铸币税值
    y_values = compute_seign(x_values, α)

    # 绘制函数
    plt.plot(x_values, y_values, 
            label=f'拉弗曲线')
    for π, label in zip(πs, [r'$\pi_l$', r'$\pi_u$']):
        plt.text(π, plt.gca().get_ylim()[0]*2, 
                 label, horizontalalignment='center',
                 color='brown', size=10)
        plt.axvline(π, color='brown', linestyle='--')
    plt.axhline(g, color='red', linewidth=0.5, 
                linestyle='--', label='g')
    plt.xlabel(r'$\pi$')
    plt.ylabel('铸币税')
    plt.legend()
    plt.show()

# 稳态拉弗曲线
plot_laffer(model, (π_l, π_u))

findfont: Failed to find font weight normal, now using 600.
findfont: Failed to find font weight normal, now using 600.
_images/6a8a4d2c1db6576ff1774ceb81d1d79ebb1d294c73fe6e2e7275849183a0bd1d.png

Fig. 32.1 稳态通胀的铸币税功能。棕色虚线代表 \(\pi_l\) 和 \(\pi_u\)。#

32.5. 初始价格水平的计算#

现在我们已经掌握了两个可能的稳态，我们可以计算两个函数 \(\underline p(m_0)\) 和 \(\overline p(m_0)\)，作为时间 \(t\) 时 \(p_t\) 的初始条件。这意味着我们需要找到对于所有 \(t \geq 0\)， \(\pi_t = \overline \pi\)。

函数 \(\underline p(m_0)\) 将会与较低的稳态通货膨胀率 \(\pi_l\) 相关联。

函数 \(\overline p(m_0)\) 将会与较高的稳态通货膨胀率 \(\pi_u\) 相关联。

def solve_p0(p0, m0, α, g, π):
    return np.log(np.exp(m0) + g * np.exp(p0)) + α * π - p0

def solve_p0_bar(model, x0, π_bar):
    p0_bar = fsolve(solve_p0, x0=x0, xtol=1e-20, args=(model.m0, 
                                                       model.α, 
                                                       model.g, 
                                                       π_bar))[0]
    return p0_bar

# 计算与 π_l 和 π_u 关联的两个初始价格水平
p0_l = solve_p0_bar(model, 
                    x0=np.log(220), 
                    π_bar=π_l)
p0_u = solve_p0_bar(model, 
                    x0=np.log(220), 
                    π_bar=π_u)
print(f'关联的初始 p_0s 是: {p0_l, p0_u}')

关联的初始 p_0s 是: (np.float64(5.615742247288046), np.float64(7.14478978438031))

32.5.1. 验证#

首先，让我们编写一些代码来验证，如果初始对数价格水平 \(p_0\) 取我们刚刚计算的两个值之一，那么通货膨胀率 \(\pi_t\) 将对所有的 \(t \geq 0\) 保持恒定。

下面的代码进行了验证。

# 实现上述伪代码
def simulate_seq(p0, model, num_steps):
    λ, g = model.λ, model.g
    π_seq, μ_seq, m_seq, p_seq = [], [], [model.m0], [p0]

    for t in range(num_steps):
        
        m_seq.append(np.log(np.exp(m_seq[t]) + g * np.exp(p_seq[t])))
        p_seq.append(1/λ * p_seq[t] + (1 - 1/λ) * m_seq[t+1])

        μ_seq.append(m_seq[t+1]-m_seq[t])
        π_seq.append(p_seq[t+1]-p_seq[t])

    return π_seq, μ_seq, m_seq, p_seq

π_seq, μ_seq, m_seq, p_seq = simulate_seq(p0_l, model, 150)

# 在稳态下检查 π 和 μ
print('π_bar == μ_bar:', π_seq[-1] == μ_seq[-1])

# 检查稳态下的 m_{t+1} - m_t 和 p_{t+1} - p_t
print('m_{t+1} - m_t:', m_seq[-1] - m_seq[-2])
print('p_{t+1} - p_t:', p_seq[-1] - p_seq[-2])

# 检验 exp(-αx) - exp(-(1 + α)x) = g
eq_g = lambda x: np.exp(-model.α * x) - np.exp(-(1 + model.α) * x)

print('eq_g == g:', np.isclose(eq_g(m_seq[-1] - m_seq[-2]), model.g))

π_bar == μ_bar: False
m_{t+1} - m_t: 1.6930797322614524
p_{t+1} - p_t: 1.693079732261424
eq_g == g: True

32.6. 计算均衡序列#

我们将采用类似于 通过货币资助的政府赤字和价格水平 中的 方法2。

我们将时间 \(t\) 的状态向量视为对 \((m_t, p_t)\)。

我们将 \(m_t\) 视为一个 自然状态变量，而 \(p_t\) 视为一个 跳跃 变量。

定义

\[ \lambda \equiv \frac{\alpha}{1 + \alpha} \]

让我们重写方程 (32.1) 为

(32.5)#\[ p_t = (1-\lambda) m_{t+1} + \lambda p_{t+1} \]

我们将用以下伪代码来总结我们的算法。

伪代码

伪代码的核心是对以下从时间 \(t\) 的状态向量 \((m_t, p_t)\) 到时间 \(t+1\) 的状态向量 \((m_{t+1}, p_{t+1})\) 的映射进行迭代。

  • 从时间 \(t \geq 0\) 给定的一对 \((m_t, p_t)\) 出发

    • 求解 (32.2) 得到 \(m_{t+1}\)

    • 求解 (32.5) 得到 \(p_{t+1} = \lambda^{-1} p_t + (1 - \lambda^{-1}) m_{t+1}\)

    • 计算通货膨胀率 \(\pi_t = p_{t+1} - p_t\) 和货币供应增长率 \(\mu_t = m_{t+1} - m_t\)

接下来，计算上文所述的两个函数 \(\underline p(m_0)\) 和 \(\overline p(m_0)\)

现在按如下方式启动该算法。

  • 设定 \(m_0 >0\)

  • 设定一个 \(p_0 \in [\underline p(m_0), \overline p(m_0)]\) 的值，并在时间 \(t = 0\) 形成对 \((m_0, p_0)\)

从 \((m_0, p_0)\) 出发，对 \(t\) 进行迭代，直至 \(\pi_t \rightarrow \overline \pi\) 和 \(\mu_t \rightarrow \overline \mu\) 收敛

结果将表明：

  • 如果它们存在，极限值 \(\overline \pi\) 和 \(\overline \mu\) 将是相等的

  • 如果极限值存在，有两个可能的极限值，一个高，一个低

  • 对于几乎所有初始对数价格水平 \(p_0\)，极限 \(\overline \pi = \overline \mu\) 是更高的值

  • 对于两个可能的极限值 \(\overline \pi\) 中的每一个，存在一个独特的初始对数价格水平 \(p_0\)，它意味着所有 \(t \geq 0\) 的 \(\pi_t = \mu_t = \overline \mu\)

    • 这个独特的初始对数价格水平解决了 \(\log(\exp(m_0) + g \exp(p_0)) - p_0 = - \alpha \overline \pi\)

    • 上述关于 \(p_0\) 的方程源自 \(m_1 - p_0 = - \alpha \overline \pi\)

32.7. 拉弗曲线动态的不稳定性#

现在我们已经具备了从不同的 \(p_0\) 设定出发计算时间序列的能力，就像在通过货币资助的政府赤字和价格水平中那样。

Hide code cell content

 
def draw_iterations(p0s, model, line_params, p0_bars, num_steps):

    fig, axes = plt.subplots(4, 1, figsize=(8, 10), sharex=True)
    
    # 预先计算时间
    time_steps = np.arange(num_steps) 
    
    # 在对数刻度上绘制前两个y轴
    for ax in axes[:2]:
        ax.set_yscale('log')

    # 遍历 p_0s 并计算一系列的 y_t
    for p0 in p0s:
        π_seq, μ_seq, m_seq, p_seq = simulate_seq(p0, model, num_steps)

        # 绘制 m_t
        axes[0].plot(time_steps, m_seq[1:], **line_params)

        # 绘制 p_t
        axes[1].plot(time_steps, p_seq[1:], **line_params)
        
        # 绘制 π_t
        axes[2].plot(time_steps, π_seq, **line_params)
        
        # 绘制 μ_t
        axes[3].plot(time_steps, μ_seq, **line_params)
    
    # 绘制标签
    axes[0].set_ylabel('$m_t$')
    axes[1].set_ylabel('$p_t$')
    axes[2].set_ylabel(r'$\pi_t$')
    axes[3].set_ylabel(r'$\mu_t$')
    axes[3].set_xlabel('时间')
    
    for p_0, label in [(p0_bars[0], '$p_0=p_l$'), (p0_bars[1], '$p_0=p_u$')]:
        y = simulate_seq(p_0, model, 1)[0]
        for ax in axes[2:]:
            ax.axhline(y=y[0], color='grey', linestyle='--', lw=1.5, alpha=0.6)
            ax.text(num_steps * 1.02, y[0], label, verticalalignment='center', 
                         color='grey', size=10)
    
    # 强制整数轴标签
    axes[3].xaxis.set_major_locator(MaxNLocator(integer=True))

    plt.tight_layout()
    plt.show()

# 从 p0_l 到 p0_u 生成一个序列
p0s = np.arange(p0_l, p0_u, 0.1) 

line_params = {'lw': 1.5, 
              'marker': 'o',
              'markersize': 3}

p0_bars = (p0_l, p0_u)
              
draw_iterations(p0s, model, line_params, p0_bars, num_steps=20)
_images/098ac6e3c4fa472412273471e1b2b0141c3acfc0d76ece0cc482535e7f53bd06.png

Fig. 32.2 从不同的初始值 \(p_0\) 开始，\(m_t\)（顶部面板，\(m\) 使用对数刻度），\(p_t\)（第二面板，\(p\) 使用对数刻度），\(\pi_t\)（第三面板）和 \(\mu_t\)（底部面板）的路径#

观察 Fig. 32.2 中的价格水平路径，我们发现几乎所有路径都收敛到稳态拉弗曲线中所示的较高通货膨胀税率，如图 Fig. 32.1 所示。

这再次证实了我们所说的在理性预期下的”反常”动态现象——系统收敛到两个可能的静态通货膨胀税率中较高的那个。

这些动态之所以”反常”，不仅是因为它们意味着选择通过印钞来为政府支出融资的货币和财政当局最终会施加比融资政府支出所需更高的通货膨胀税，还因为通过观察图 Fig. 32.1 中所示的稳态拉弗曲线，我们可以推断出以下”违反直觉”的情形：

  • 该图表明，通过运行更高的政府赤字，即通过印钞筹集更多资源，可以降低通货膨胀。

Note

在研究本讲座模型线性版本的 通过货币资助的政府赤字和价格水平 中，同样的定性结果也普遍存在。

我们发现：

  • 除了一条均衡路径之外，所有均衡路径都收敛于两个可能的静态通货膨胀税率中较高的那个

  • 存在一条独特的均衡路径，它与关于政府赤字的减少如何影响静态通货膨胀率的”合理”论断相关联

正如在 通过货币资助的政府赤字和价格水平 中一样，基于合理性的考虑，我们再次建议选择收敛于较低静态通货膨胀税率的那条独特均衡路径。

我们将会看到，接受这一建议是我们在 一些不愉快的货币主义算术 中描述的”令人不快的算术”结果的一个关键要素。

在 拉弗曲线与自适应预期 中，我们将探讨 [Bruno and Fischer, 1990] 等人如何以其他方式论证我们的均衡选择的合理性。

32.8. 练习#

Exercise 32.1

峰值铸币税收入与财政限制。

在通货膨胀率 \(x\) 下的稳态铸币税为

\[ L(x) = e^{-\alpha x} - e^{-(1+\alpha)x}. \]

a. 通过求导，令 \(L'(x) = 0\) 并求解 \(x\)，从解析角度验证 \(L(x)\) 在

\[ x^* = \ln\!\left(\frac{1+\alpha}{\alpha}\right) \]

处取得最大值。

b. 使用默认模型，根据解析公式计算 \(x^*\)，用 scipy.optimize.minimize_scalar 进行数值验证，并绘制拉弗曲线，同时用水平线标出 \(g_{\rm max} = L(x^*)\) 和基准赤字 \(g = 0.35\)。

c. 对于 \(g = g_{\rm max} + 0.01\)，在细分的 \(x\) 值网格上评估 \(L(x) - g\)，并解释如果政府试图为 \(g > g_{\rm max}\) 的赤字融资会发生什么。

Exercise 32.2

两个稳态通货膨胀率如何依赖于赤字 \(g\)。

本讲座计算了固定基准赤字 \(g = 0.35\) 下的 \(\pi_l\) 和 \(\pi_u\)。

a. 对于从 \(0.05\) 到刚好低于 \(g_{\rm max}\) 范围内的 \(g\)，数值计算 \(\pi_l(g)\) 和 \(\pi_u(g)\)，并将它们绘制在同一图形上。

b. 描述极限行为： - 当 \(g \to 0^+\) 时，\(\pi_l(g)\) 和 \(\pi_u(g)\) 趋向于什么？ - 当 \(g \to g_{\rm max}^-\) 时，它们又趋向于什么？

c. 在你的图上标出基准 \(g = 0.35\)，读出这两个值，并确认它们与讲座中计算的 π_l 和 π_u 一致。

Exercise 32.3

货币需求弹性 \(\alpha\) 的影响。

参数 \(\alpha\) 决定了实际货币需求对预期通货膨胀的敏感程度。

\(\alpha\) 越大，意味着随着通货膨胀上升，家庭会更大幅度地减少其实际余额。

a. 对于 \(\alpha \in \{0.3,\; 0.5,\; 0.8\}\)，计算 \(x^*(\alpha) = \ln\bigl((1+\alpha)/\alpha\bigr)\) 和 \(g_{\rm max}(\alpha) = \alpha^\alpha/(1+\alpha)^{1+\alpha}\)，然后将三条拉弗曲线绘制在同一坐标轴上。

b. 将赤字固定在 \(g = 0.35\)，检查对每个 \(\alpha\) 而言该赤字是否可行（即 \(g \leq g_{\rm max}(\alpha)\)），并对每个可行情形计算 \((\pi_l,\, \pi_u)\)。

c. 对于每个可行的 \(\alpha\)，从中点 \(p_0 = \tfrac{1}{2}(p_{0,l} + p_{0,u})\) 出发模拟20期，并将 \(\pi_t\) 绘制在同一张图上，以找出这些路径的共同点。