Financial Accelerator of Bernanke et al. (1999)

Hey Dynare Community,

I´m currently working on the paper “The Financial Accelerator in a Quantitative Business-Cycle Framework” and I tried to replicate the results using Dynare.

Regarding the implementation of the model block I have the following questions.

1.Since all my efforts failed to fulfil the Blanchard-Kahn conditions when implementing the model block, I looked at different Dynare Code examples for the BGG model in the WWW.
In this Dynare Code examples the variables r, n and k are dated one period further into the past compared to the equations in the original paper.

Example: E_t{rk_t+1} – r_t+1 = -v[n_t+1 - (q_t + k_t+1)] // Equation 4.17 in the paper
rk(+1) - r = -nu*(n -(q + k)); //Implementation of 4.17 in Dynare Code examples

Now my questions:
Is this implementation indeed right? / Don’t we harm the time structure of the BGG model?
Why is it not possible to lag equation 4.17 and implement it using an auxiliary variable for the expectation operator?

Example: E_t-1{rk_t} – r_t = -v[n_t – (q_t-1 + k_t)]
erk(-1) – r = -nu*(n – (q(-1) + k)); // My implementation of 4.17
erk = rk(+1); // auxiliary variable for 4.17

I tried to implement the BGG model this way without changing the time structure, but the model always fails to meet the BK-conditions.

  1. Looking at the Phillips curve equation (4.22) I noticed that some examples don’t take into account the expectation operator at t-1.
    Example: pi_t = E_t-1{kappa*(-x_t) + betapi_t+1} // 4.22 from the paper
    pi = kap
    (-x) + beta*pi(+1); //Implementation of 4.22 in many Dynare Code Examples
    I tried to implement equation 4.22 again by using an auxiliary.
    pi_t1 = (-1)kappax(+1)+beta *pi(+2);
    pi = pi_t1(-1);
    but it failed or changed the dynamics of the model.
    Why do I have to implement 4.22 like above?

Because I’m a bloody beginner I’m very thankful for any helpful comments.
I add my .mod-file for the BGG model below. FinancialAccelerator.mod (4.0 KB)

Best regards

  1. The reason is that not the whole equation needs to be shifted in time, but rather that the two variables on the right hand side are predetermined states that need to be shifted by 1 period to conform to Dynare’s timing convention.
  2. The Phillips Curve part is tricky. The lagged information set assumption was introduced by Rotemberg/Woodford and sometimes is used in the literature. But for BGG, they do not really state what they actually used. So it is up to the reader to guess whether they actually used E_{t-1} instead E_t. You and others seem to suggest that they actually used E_t.

Thank you very much for your reply.

Let me clarify the first point.
If I understand you right, the reason for shifting r, n and k by one period into the past are simply the time conventions in the BGG-paper.
Because r, n and k are known to the lender and borrower when signing the optimal contract under costly state verification at time t the only uncertainty that remains is the uncertainty about the projects return E_t{rk_t+1}.
This is the reason why I have to take the state variables r, n and k as predetermined.
Thus I implement the equation E_t{rk_t+1} – r_t+1 = -v[n_t+1 - (q_t + k_t+1)]
by rk(+1) - r = -nu*(n -(q + k));
This is what you mean, right?
Of course, a second minor reason is that I can not implement the equation because of Dynare’s implicit expectation operator.

To the second point with the Phillips curve.
I assume that it is hard to implement the Philips Curve Equation which can be found in the original BGG-paper, because when implementing pi_t = E_t-1{kappa*(-x_t) + betapi_t+1}
I have to apply an auxiliary variable.
Thus I implement pi_t = E_t-1{kappa
(-x_t) + beta*pi_t+1}
by pi_t1 = (-1)kappax(+1)+beta *pi(+2);
pi = pi_t1(-1);
Now the problem arises that Dynare counts pi(+2) for two forward looking variables which implies that the preprocessor terminates the computation with a warning (indeterminacy).

  1. Yes, your intuition about the timing is right
  2. Regarding the NKPC, you could use the `EXPECTATION’ operator to do this (see the manual)