Coupled Riccati Recursions for Regime-Switching Asset Pricing

Definition

A pair of linear, time-varying recursions for the affine loading (intercept, slope) of an exponential-affine pricing kernel evaluated conditional on a fixed Markov regime path. Conditional on the path π = (S_t, ..., S_{t+n−1}), the price of an n-period claim of the form E_t^Q[exp(∑_{s=t}^{t+n−1} ψ_s' x_s)] is exp(α_n + β_n' x_t) where (α_n, β_n) satisfy first-order linear recursions in n whose coefficients depend on the regimes visited along the path.

For the Leather-Sagi CRE model these specialize to two cases:

• Bond case (3-D macro state x_t, payoff e^{−r_t}):

  • b_{n+1} = Φ^Q(S_{t+1})' b_n − e_r
  • a_{n+1} = a_n + b_n' m^Q(S_{t+1}) + ½ b_n' Σ(S_{t+1}) Σ(S_{t+1})' b_n
  • (a_0, b_0) = (0, 0)

• Dividend-strip case (4-D augmented state z_t = (x_t', ν_{j,t})', payoff e^{ν_{j,t} − r_t}):

  • β_{n+1} = Φ_z^Q(S_{t+1})' β_n + h, with h = e_ν − e_r = (0, 0, −1, 1)'
  • α_{n+1} = α_n + β_n' m_z^Q(S_{t+1}) + ½ β_n' Σ_z(S_{t+1}) Σ_z(S_{t+1})' β_n
  • (α_0, β_0) = (0, 0)

The unconditional price is recovered by averaging over the 4^n (or S^n more generally) regime paths weighted by Markov transition probabilities ∏_k P(S_{t+k+1} | S_{t+k}). The continuation value is closed via a constant Q_j^* solved as a fixed point.

Intuition

Two ideas combine to make these recursions work:

1. Conditional linearity. Once the regime path is fixed, the model collapses to a (time-varying) linear-Gaussian VAR. The exponential-affine guess is closed under such VARs because the Gaussian moment generating function is itself exponential-quadratic in the state, and after collecting x_t terms the quadratic part exactly matches the next-step affine guess.

2. Path-by-path averaging. The unconditional price is a finite mixture over regime paths. The Markov chain provides the mixing weights, and pruning low-probability paths gives a controllable approximation. This cleanly separates the Riccati problem (linear, deterministic) from the Markov problem (combinatorial, but path probabilities decay fast).

The dividend-strip Riccati is the same machinery as the bond Riccati after augmenting the state with the income process and switching the payoff selector from −e_r to h = e_ν − e_r.

Formal notation

Let x_t ∈ R^d follow x_t = m^Q(S_t) + Φ^Q(S_t) x_{t−1} + Σ(S_t) ε_t^Q with ε_t^Q ~ N(0, I). For a payoff exp(ψ' x_t) per period and a path π = (S_t, ..., S_{t+n−1}), the path-conditional n-period price P_n^π(x_t) = exp(α_n + β_n' x_t) satisfies:

β_{n+1} = Φ^Q(S_{t+1})' β_n + ψ
α_{n+1} = α_n + β_n' m^Q(S_{t+1}) + ½ β_n' Σ(S_{t+1}) Σ'(S_{t+1}) β_n

with (α_0, β_0) = (0, 0). The Jensen / convexity term ½ β_n' Σ Σ' β_n is what makes the recursion respond to time-varying cash-flow volatility.

The unconditional price is P_n(x_t, S_t = i) = ∑_π P(π | S_t = i) exp(α_n^π + (β_n^π)' x_t).

Variants

• Bond strip (ψ = −e_r, scalar r_t = e_r' x_t): produces (a_n, b_n) with b_n always negative-leaning toward −e_r. Used directly for bond yields y_{t,t+n} = −(4/n) ln B_{t,t+n}.
• Dividend strip on augmented state (ψ = h = e_ν − e_r, augmented z_t): produces (α_n, β_n) for CRE income strips. This is the variant the production code (compute_quadratic_pricing_factors_msvar) implements.
• Conditional second-moment recursion (Bikbov-Chernov Appendix C): an analogous quadratic-state recursion for E[(∑ x_s)^2], used to compute the long-run variance σ²_LR in Section 6 of the source note.
• Stacked first-moment recursion (Section 6.4 of the source note): not path-conditional — instead, all S regimes are stacked into a 3S-vector and the recursion becomes a single linear system in K = block(π_{ij} Φ^Q(j)). Useful for computing the limit B_∞ = (I − K)^{−1} Δ.
• Physical-measure twin: the same recursions hold under the physical measure P by replacing (m^Q, Φ^Q) with (m, Φ), used to compute physical-measure cap rates and thence risk premia.

Comparison

• Vs. single-regime affine term structure (Duffie-Kan, Dai-Singleton): identical structure within a regime, but the regime-switching version requires path enumeration and the steady-state loading is the fixed point of a coupled across-regime system, not a single-regime linear solve. Path averaging is what makes the difference.
• Vs. direct Monte-Carlo simulation of strips (SimMdlPrices/src/mc_strips.jl in the project): the Riccati path produces an exact (up to path pruning) closed-form, while MC has finite sample noise. Riccati is much faster per evaluation but requires the Gaussian / linear structure; MC is the correct fall-back when one or both fails.
• Vs. Markov-modulated Lyapunov equations (MJLS literature, Costa-Fragoso-Todorov): the stacked first-moment recursion B_{N+1} = Δ + K B_N is exactly the discrete-time Lyapunov equation for the Markov-modulated system, and (I − K)^{−1} Δ is its closed-form steady state.

When to use

• Pricing claims of exponential-affine form (zero-coupon bonds, dividend strips, real estate cap rates) under a regime-switching essentially-affine VAR with Gaussian innovations.
• Building cap rates or yield curves analytically as a function of structural parameters, e.g., inside an MLE inner loop where MC noise would be prohibitive.
• Verifying convergence of the strip sum analytically via the steady-state loading (B_∞) before paying for path enumeration.
• As the analytic comparator for any Monte-Carlo pricing scheme (e.g., the project’s mc_pricer.jl / mc_strips.jl pipeline) — Riccati is the gold standard within its assumptions.

Known limitations

• Path enumeration cost: the S^n regime paths grow fast in n. Bikbov-Chernov path pruning is accurate to n ≈ 40 quarters but is heuristic.
• Per-regime stability is not enough. Even when every Φ^Q(S) has spectral radius < 1, the stacked persistence matrix K can be unstable. The Riccati iteration then diverges for the stacked / unconditional quantities, even though path-conditional prices are finite for any individual finite-n path. Stationarity must be checked at the level of K, not per-regime.
• Boundary blow-up: parameters near the no-bubble boundary cause the ½ β' Σ Σ' β term to grow rapidly, and naive Riccati iteration loses precision. The smooth NBC barrier from the source note is the recommended remedy.
• Non-Gaussian innovations: the closed form relies on the Gaussian MGF. Extensions to jump-diffusion or stochastic-volatility innovations require a more general transform analysis (Duffie-Pan-Singleton) and the recursions become quadratic / nonlinear.
• Path-pruning bias: truncating low-probability regime paths introduces a one-sided bias in the price approximation that is not easily quantified analytically.

Open problems

• A non-heuristic, error-bounded path-pruning scheme.
• Analytic conditions on (Π, Φ^Q, Σ) under which the stacked Riccati error is O(ρ(K)^n) versus merely o(1).
• Extension to multi-asset payoffs with cross-asset regime correlations beyond the simple block-triangular augmentation.
• Tight characterization of when stacked vs. absorbing steady-state loading is more accurate (see spectral-radius-test-markov-pricing-operator).

Key papers

• riccati-equations-leather-sagi — explicit derivation of bond and dividend-strip Riccati recursions for the regime-switching CRE model, including the augmented (macro, income) state and the ergodic stacked-system extension for long-run variance.

My understanding

The recursions are mechanical once you commit to “conditional on a regime path, life is linear-Gaussian, so prices are exponential-affine.” The interesting work is in the averaging step (regime path enumeration vs. pruning) and in the steady-state characterization, which is where the stacked persistence matrix K and its eigenvalue condition ρ(K) < 1 enter. In production code, the compute_quadratic_pricing_factors_msvar function in SimMdlPrices.jl is the dividend-strip Riccati from Section 4 of the source note, with δ as a row vector SMatrix{1,6}. The bond Riccati is the same code path with a different ψ.