Vanguard Nest Egg Calculator

• Underlying code

• Underlying data

This is for /u/JirenTheGay who asked a question about financial planning here.

RI

The Vanguard Nest Egg calculator tells you how long your savings will last if you spend $X each year. The inputs are your initial balance, yearly spending, and portfolio allocation ( historical data). The portfolio allocation is composed of stocks/bonds/cash with returns being subject to inflation risk. Specfiically,

For stock market returns we use the Standard & Poor’s 500 Index from 1926 to 1970, the Dow Jones Wilshire 5000 Index from 1971 through April 2005, and the MSCI US Broad Market Index thereafter. For bond market returns, we use the Standard & Poor’s High Grade Corporate Index from 1926 to 1968, the Citigroup High Grade Index from 1969 to 1972, the Barclays US Long Credit AA Index from 1973 to 1975, and the Barclays Capital US Aggregate Bond Index thereafter. For the returns on short-term reserves (i.e., ‘cash’), we use the Citigroup 3-Month Treasury Bill Index. For inflation, we use the changes in the annual Consumer Price Index from 1926 through last year.

The output is a set of potential paths your savings balance can take. It is produced by running 100,000 Monte Carlo simulations where data is drawn independently from the set of historical returns.

The bad economics is the use of independent draws from the data to simulate future returns. This procedure is basically just a bootstrap, but we'll call it an "IID Bootstrap" since there are many kinds of bootstrap algorithms. Using an IID bootstrap is bad, because it ignores time dependence in the historical returns data.

Time dependence is important because the probability of going broke with fixed drawdowns varies with the path of returns.

Simple example: $1 million savings and $500k draw down. Suppose you either get -10% log return or 10% log return (this is -9.51%/ 10.52% pct return)

Scenario 1 -- Good return first
   Period 0: $1 million
   Period 1: (1.1052-0.5) = $0.605 million
   Period 2: (0.5476-0.5) = $0.047 million

Scenario 2 -- Bad return first
   Period 0: $1 million
   Period 1: (0.9049 - 0.5) =  $0.405 million
   Period 2: (0.4475 - 0.5) = -$0.052 million 

You go broke in scenario 2 even though the good return plus bad return cancel out: (1 0.1052)*(1-0.0951) ≈ 1. Hence, the order of the returns matters.

But, aren't stock returns supposed to be IID?

If we assume stocks follow a random walk with some drift, then returns are IID with a mean equal to the drift. However, people generally accept that volatility is predictable. That is, we may not be able to forecast return r_t, but it is possible to forecast r_t^2. This model generally looks like

p_t = p_{t-1}   mu   e_t*sigma_t
    =>  r_t = mu   e_t*sigma_t 

where p is the price, mu is the drift, and e_t is some IID random variable (can assume Gaussian if you want). The term sigma_t captures time-varying volatility. All the variables here are logged, so the difference in prices gives the return r_t. The reason time-dependent volatility matters is that it creates a connection between the path of past returns and future returns. I've written more about this here, but basically all you need to know is that volatility is autocorrelated. So, if run a Monte Carlo while taking independent samples (IID Bootstrap), the new series of returns will have no autocorrelation in volatility. This messes up the path of returns which matters when doing to the retirement simulation.

Some intuition: Suppose conditional return for some period is Gaussian. If the return is sufficiently small/negative, then you might not have enough to savings to meet your yearly spending. As a result, the probability of going broke will depend on the variance of the return: mspaint_graph -- norm_cdf(x, mu, sigma) is increasing in sigma for x < mu. Since the variance of the return depends on past returns, incorrectly using returns that follow the unconditional variance (a consequence of independent sampling) will mess up the variance for the simulated returns => wrong time path for the portfolio simulation => messes up estimates for the probability of going broke. Hence, even if returns can't be predicted, the dependence of volatility can break the IID bootstrap.

How do we deal with this problem?

A better approach would be to use some sort of block bootstrap -- this is like a regular bootstrap but we grab contiguous 'blocks' of data. For example, if our data was [1,2,3,4,5,6], a block bootstrap sample might be [2,3,4,1,2,3] (block size of 3). Notice that if we use a block bootstrap with a block size of 1, we get the traditional bootstrap. The statistical theory behind a block bootstrap is that you can set the size of the blocks to grow with the number of samples. So, as the sample size gets arbitrarily large, the block sizes get arbitrarily large, which allows the procedure to capture increasing amounts of time-dependency. At the same time, we need the number of blocks to increase with the sample size; this means that the block sizes should grow at an intermediate rate -- fast enough that they get bigger with sample size, but slow enough that the number of blocks also grows with sample size: shitty ms paint graph. There's also some lecture notes here on more complex bootstraps. I will use the stationary bootstrap which is a kind of block bootstrap where the size of the blocks is follows an exponential distribution with a mean block length parameter.

Do block bootstrap methods work? Here's an example with some ARMA(1,1) data and a plot that shows the autocorrelation. Notice that the IID bootstrap kills all the autocorrelation. However, the series formed from a stationary bootstrap retains its autocorrelation; also, the autocorrelations for the original series and the stationary bootstrap series are fairly close. Hence, estimates based on the traditional bootstrap don't seem to work with non-IID data, but the stationary bootstrap appears to capture the dependence reasonably well.

Replicating/Updating Vanguards Results

To start, I replicate the results from VG's calculator in Python. It works in a pretty simple way. Each year, (1) the yearly spending amount is adjusted for inflation using CPI data; (2) the adjusted spending is subtracted from the the account balance; (3) the account balance grows according to the portfolio return. The portfolio return is a weighted combination of the stock/bond/cash returns where the weights are supplied by the user. Also, VG uses 100k bootstrap replications.

With the default parameters, VG says there is a 83% chance of going broke after 30 years and a 62% chance of going broke after 50 years. The respective results from my code are 82.84% and 62.03%. So, I can replicate the results for the default params. Also, I was able to replicate for other sets of parameters, so I think my code replicates the VG calculator.

Next, I introduce a stationary bootstrapping into the calculator. I use an average block length of 10 for the stationary bootstrap; optimal block lengths for each series (stocks/bonds/cash/cpi) vary around this number. Overall, this approach should account for time dependency in the returns. Surprisingly, for the default parameters, there's little change. There's two possible reasons for this. (1) We are using yearly data, which will have less time-dependency than say monthly data. And, (2) the default allocation is 50% stocks which have little yearly time dependence (although a lot of higher-frequency dependence). Point (1) also raises another concern; people usually draw down from their portfolio every month for spending rather than pulling their entire yearly budget out at the beginning of the year. This definitely impacts the calculations, and we could handle it if we had monthly return data. Point (2) can be addressed by just considering different parameters. For instance, since older people probably hold more safe assets, we might expect them to hold more bonds. In this case, some possible allocations are:

• 10/80/10 Allocation

• 20/60/20 Allocation

• 30/70/0 Allocation

• 10/70/20 Allocation

Most of these look quite different from the IID bootstrap approach. I would guess it's because there's more bonds in these allocations, although it's hard to nail down the reason because there might be all sorts of wild things going on with auto and cross-correlations.

Additionally, here's another example with the default parameters but with 75k yearly drawdown. In the default parameter case, the stationary line was always above the IID line. But, if we increase drawdowns, these lines cross one another several times. This behavior persists even if I use 1 million bootstrap replications instead. Since the only difference between the approaches is the bootstrap type, it's probably due to complicated time dependencies. It's hard to explain more than that, since there might be all sorts of stuff going on. For instance, it's possible for the volatility to time vary with the sign of returns (leverage effect), for negative and positive volatility to have different correlations (semivariance), maybe there's regime changes, idk. Anyways, all of this would be accounted for using the stationary bootstrap (with some regularity conditions on the underlying DGP).

Overall, it looks like using a stationary bootstrap affects the results and sometimes significantly. Hence, the IID bootstrap used by VG is problematic.

You can run the notebook yourself from here. Just rename as .ipynb, and don't complain about the code 😤.