8. Managing a Competitive Tontine Business

Since the modern tontine competes head-on with the traditional life annuity issued by a conventional insurance company it’s very tempting for the sponsor to go beyond the sharing of investment gains & losses and offer some investment guarantees. Of course, if you have reached this stage (and page) you know that the entire raison detre of the modern tontine is to avoid guaranteeing or promising anything. That dire warning was issued back when death benefits as well as surrender features were introduced. Nevertheless, this next section ponders what might happen if the sponsor were to implement a rule—not necessary a guarantee—that actual tontine dividends would never be less than some pre-determined floor. What would be the implications on the evolution of the fund and the dividends if that (hard) floor were mercilessly adhered to regardless of markets? Could this ruin the fund? And if so, when?

The next bit helps shed light on this precise question. It should be used after the user has generated a simulation run in which the tontine dividend has indeed been forcefully floored by augmenting the relevant line in the standard script to read: TONDV[i,j]=max(,kfloor*f0). The argument to the left of the comma would represent the un-floored dividend and the parameter kfloor itself would be set as a fixed percentage of the initial investment f0. For example, echoing the above discussion, the sponsor might include a provision that annual tontine dividends will never be declared or distributed at less than a kfloor value of 4%, or more precisely $4 per original $100 investment. The floor would never be applied to the current fund value DETFV or the current net asset value, which would make no sense. Rather, the floor would be relative to the original investment f0. The target payout would remain kappa[1], which would obviously be greater than the floor. Notwithstanding the inability of a fund company to guarantee such a policy outside of an insurance (partnership or) environment, the following R-script computes the failure rate (a.k.a. ruin probability) when implementing this particular feature in a modern tontine.

Now mechanically, when forcefully flooring the tontine dividend the “future” might generate scenarios in which the (new) dividend policy creates enough downward pressure on the underlying fund to force a premature collapse. That eventuality must also be dealt with in the R-script using max(,0) within the construction of DETFV[i,j]. Max mitigates any investment shocks that could lead to negative fund values, which is not allowed. The fund can’t borrow against non-existent assets. Thus we are now ready to look for failures. The next R-script searches year by year over the horizon TH and keeps track of the number of cases in which the fund value hits zero (or less, just to be safe). Remember: true tontines never die prematurely, they just fade away! Nevertheless, the following run uses kfloor=0.04, which is 50 basis points higher than the investment return of r = ν = 3.5%; all to see what happens when floors are higher than discount rates. That said, the initial value: κ = 6.658% because of the mortality credits. The anticipated tontine dividend yield is 266 basis points above the floor. Here are the parameters I am using for this simulation.

                  
                    x<-65; m<-90; b<-10; GL0<-1000; TH<-30; N<-10000
                  
                  
                    EXR<-0.035; SDR<-0.07; r<-0.035; f0<-100;
                  
                  
                    kfloor=0.04
                  
                  
                    # Parameters that Govern lapsation and redemption.
                  
                  
                    eta0<- rep(0.02,15)
                  
                  
                    eta<-c(eta0,rep(0,TH-length(eta0))); dsc<-0.03
                  
                

Here finally is the script and results.

                  
                    ruin4<-c()
                  
                  
                    for (i in 1:TH){fund<-DETFV[,i]
                  
                  
                      ruin4[i]<-length(fund[fund<=0])/length(fund)}
                  
                  
                    ruin4
                  
                

                  
                     [1] 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
                  
                  
                     [9] 0.0000 0.0000 0.0000 0.0000 0.0000 0.0006 0.0015 0.0040
                  
                  
                    [17] 0.0068 0.0102 0.0160 0.0226 0.0293 0.0369 0.0459 0.0557
                  
                  
                    [25] 0.0642 0.0745 0.0867 0.1012 0.1205 0.5780
                  
                

In terms of the (simple) mechanics, the loop counts the number of elements in the newly defined fund vector that are less than or equal to zero via the length command and divides that by the total number of simulation runs (yes, usually 10,000) via another call to length. The loop starts with the i=1 fund value at the end of the first year of the modern tontine and ends at the final year TH. There are a number of interesting (business) takeaways from this particular run, in which I used the usual (x = 65, m = 90, b = 10) demographic parameters, as well as a 2% lapse rate, a 3% surrender charge penalty on lapsing in the first 15 years, plus a full death benefit of the unreturned premium.

Figure 8.1 provides another perspective on the financial implications of this floor, plotting the tontine dividends (left panel) and fund value (right panel). Notice that in the first few years or so, there are no (statistical) scenarios in which the tontine dividends fall to the floor. In the language of mathematical optimization the constraint isn’t binding in that region. Why? Well, the fund value DETFV[i,j] multiplied by the relevant kappa[j] value and divided by the number of survivors GLIVE is greater than above-noted $4,000 per survivor. The problems start to appear (on the left) towards the end of the first decade. We start to see some scenarios in which the floor is binding and the counterfactual (nonfloor) would have been pierced had that pledge not been made.

The panel on the right of Fig. 8.1 provides yet another perspective on the failure of the tontine fund when floors are (gratuitously) offered without any further modifications or restrictions. Notice how in this panel the problems become visible between year 15 and 20, when the 1% lower-bound curve hits zero. To be more precise that happens between year #17 and #18, when the above-noted R-script produced ruin4[18] above 1%. The large range of values for both the fund value DETFV as well as the TONDV is typical of high-volatility investments (reminder: σ = 7%), which was done deliberately to accentuate and accelerate ruin. What is not typical or standard for the modern tontine is the lower bound of the right-hand panel hitting zero before the end of life.

Regardless of what these two pictures in Fig. 8.1 might be saying about the importance of year #15 (dividends), or year #18 (fund values), in the unravelling and collapse of the tontine, the blame—if there is any beyond the sponsor’s misguided generosity—lies in the investment returns during the very early years of the fund. Using the set.seed(1693), now users should be able to reproduce the following fund values and standard deviations. (Note the occasionally I have generated results or numbers by using a different seed, which is why I note this here.)

                  
                    mean(DETFV[,25])
                  
                  
                    > 7594.718
                  
                  
                    sd(DETFV[,25])/mean(DETFV[,25])
                  
                  
                    > 0.5653603
                  
                  
                    mtrx<-cbind(PORET[,1],DETFV[,25])
                  
                  
                    > cor(mtrx)
                  
                  
                              [,1]      [,2]
                  
                  
                    [1,] 1.0000000 0.2945066
                  
                  
                    [2,] 0.2945066 1.0000000
                  
                

The average fund value at the end of year #25 is $7.6 million—remember that DETFV is in thousands—but the standard deviation (risk, dispersion, variability) of the fund value in its 25th year of life is almost 57% of the expected value. More importantly and relevant to the question of assigning blame for failure, the correlation between the vector of year #25 values and the vector of year #1 investment returns (separated by a quarter of a century!) is almost 30%. Notice the very high (and alarming) impact of the first few years of the fund on the long term evolution of tontine dividends and the failure rate. Alas, this devil has another name: sequence of returns.

This rather alarming situation is driven by the unrealistically high constraint imposed by a 4% floor, and it’s unlikely any (rational) sponsor would go near such a number (or promise). But what about a 3% or 2% floor? The cumulative failure rates should be lower with looser floors, and indeed results are consistent with intuition. Using the ruinx[j] to denote the cumulative failure rate in year [j] under a floor of x, the above-noted script can be easily modified with minimal surgery.

                  
                    ruin4[25]
                  
                  
                    > 0.0642
                  
                  
                    ruin3[25]
                  
                  
                    > 0.0348
                  
                  
                    ruin2[25]
                  
                  
                    > 0.0228
                  
                

Note that depending on what other things you have been calculating and generating at the same time, your simulation results might differ slightly from mine. By I should note (again) that in order to calculate the ruinx values, you should rerun the entire script and make sure to set the kfloor value to percentage representing that rate.

I selected year #25 and the cumulative (vs. yearly) failure rate as a baseline for comparison across strategies and floors. The ruinx[j] values for the first decade or two of life would be rather boring and close to zero. Hence, if a particular year is selected for benchmarking, it shouldn’t be too early—or too late either. Why not the entire horizon? Well, at the very final year of the modern tontine’s life, the fund is actually designed to be ruined. So, there should be zeros lurking around that vector. It’s the years before TH in which zeros shouldn’t be visible. To sum up, Figure 8.2 plots the cumulative failure rate over the life of the modern tontine fund under a variety of floor values, ranging from 2% (not very binding) to 4% (much too tight), with investment assumptions and parameters noted within the figure. The 5% failure rate is noted prominently on the horizon.

To sum up this discussion, in my opinion failure rates that exceed 1%—or for that matter even a quarter of that—should simply be unacceptable to the sponsor, which means that offering such a promise, guarantee or consumer expectation contravenes the entire purpose of the fund: guarantee nothing. Nevertheless, if a tontine sponsor does want to create a meaningful flooring covenant for its members—similar to the death benefit or lapse value covenant from Chap. 5, there are a few possible paths forward that one could take. The first is to mandate risk-control for the asset allocation and investments within the fund, especially in the early years; mitigating sequencing risk. The costs and benefits of that strategy, within the context of dividend stability, is something worthy of quite a bit of discussion on the business level.

Another possible solution to the failure rate dilemma is to place an informal cap on the tontine dividend in addition to the above modelled floor; thus building a financial reserve for the lean years. After all, the left-hand panel of Fig. 8.1 shows quite a bit of upside that could perhaps be retained by the fund. Why not hold some back? Indeed, modifying the R-script to incorporate the ceiling involves no more than a few characters and I leave that as a simple assignment. Jumping ahead I can attest that ceilings will work, and do mildly reduce the failure rates, but just barely. In some simulations they don’t help at all. But in all scenarios they leave the tontine sponsor with another moral dilemma: what do we do with leftovers?

Without getting too caught-up in thick simulation weeds, I should note that scenarios in which we observe failure or ruin are associated with dividend paths that are continuously under the initial κ value. In other words, this is yet again a manifestation of a bad sequence of returns in the early years of the modern tontine. My point is that placing a cap on dividends with the hope you might be able to build-up some reserves for the bad times might sound like a good idea, but in practice isn’t as helpful as you might think.

Finally, one last possible floor strategy is as follows. What if the sponsor held-back and skimmed the top from the Gompertz driven payout rates? Instead of payouts based on the pure kappa[j] value vector, they would subtract off a few basis points and keep that as a reserve. Could that create a cushion for the lean years and reduce the failure rate? Preliminary results indicate that it helps, and more so than ceilings which only offer an illusionary benefit. Numerically, shaving 50 basis points off the κ curve would reduce the year-25 failure rate (under a 4% floor) from the above-noted 6.42% to around one-in-twenty. Reducing the payout by a full 100 basis points would reduce the relevant failure rate to around one-in-twenty five, but it can’t be driven under the 1-in-100 threshold with any competitive and acceptable haircuts. In conclusion, these haircuts may not solve the failure problem entirely, but could move the needle in the right direction.

As we approach the tail-end of this book, one of the issues I haven’t properly addressed is the possible mixing of age and gender cohorts into one larger group of modern tontine participants. For most of the prior chapters, the given R-script has assumed an initial time-zero pool size of GL0, with each member contributing and investing exactly f0 dollars, and each participant assumed to be precisely of age x. These assumptions have been extremely convenient for the modelling and simulation projections, but in practice are highly unrealistic. First, the sign-up and onboarding period is likely to take some time. Moreover, even if GL0 investors do end-up joining the modern tontine fund, it could conceivably take place over the course of weeks and months. What happens to those who die before others have joined? Is it fair to give the newcomers those dividends? Second, and a much bigger issue is that investors are likely to (want to) invest different sums of money, not all f0 and they certainly will not share a common birthday. In fact, they might not even share a common birth year or even birth decade. Gender will also affect mortality rates. In our language, even if we assume the same (m, b) Gompertz parameters, the x is most certainly different.

Now, in theory one can get back to work and modify the R-script, the most recent one being version 3.3, to account for these modifications. Perhaps a version 3.5 of the script would allow for GL0 different investments from each of the investors. In that case, instead of a scalar f0, we would have to define and keep track of an entirely new matrix with GL0 rows and TH columns. The first column of this new matrix will contain the initial investment made, and the subsequent column would contain the tontine dividends that each one of these GL0 investors are entitled to each year, assuming they are alive. To be clear, life & death would have to be simulated based on each individual’s unique age, call it x _k with k ranging from k = 1 to GL0, versus one single age x for the entire group.

Moreover, this new matrix would have to be generated per simulation scenario, so each run would create N copies of this new matrix. The collection of individualized payout matrices would replace the one TONDV matrix, which recall didn’t properly identify the specific participant. In other words, the computer memory requirements for this sort of exercise would be enormous, at least if you want to keep track of all scenarios at the end of an experiment run.

Another and more subtle issue is how to allocate and partition tontine dividends at the end of each year (or quarter, or month) when the fund starts-off with many different investors at different ages. It’s obviously not fair (nor equitable) to distribute the same amount per initial dollar invested to everyone who happens to be alive at the end of the period. We certainly can’t multiply a universal κ value by the DETFV matrix—as we did in the core of the simulation code—and then split that pot of available money among a homogenous group of GLIVE survivors. After all, some survivors might be quite young in age (or gender) and might have invested very little, and they effectively would be subsidized by old investors who might have invested quite a bit more.

Please stop and think about that fact carefully, which is something that historical tontines struggled with in their early years during the seventeenth and eighteenth century. Elon Musk (who is currently 50 years old) invests $50 billion in a tontine. You are 30 years old and invest $30. Does that sound fair? To be clear, this isn’t just a computer size or memory issue. Rather, the fix here must involve assigning a new κ payout rate that is unique to each of the GL0 investors who are still alive, based on their age (gender) and possibly the amount they initially invested. In some cases, we might have to impose economic restrictions and the maximum and minimum investment to ensure we don’t have a lopsided gamble.

So, if I have convinced you that this mixing cohorts is economically complicated, requires a complete re-write of the R-script and must be done with utmost caution that was exactly my intention. More to the point, what I have just described goes beyond the scope of this (free) book. But the computational labour involved isn’t insurmountable, and the theory itself has been formulated by many of the researchers I highlighted in the literature review of Chap. 1. It can be done, but not here and not now.

Of course, while theory suggests it’s possible to do this fairly or at least equitably—ensuring that on average the actuarial present value all investors receive relative to their initial investment is identical—there is yet another business problem lurking in the background; securities regulation. The next step involves more than talented coders and developers. One requires clever lawyers as well. You see, if the modern tontine fund operates as a traditional collective investment trust, the process of allocating and paying dividends that depend on investor’s age or gender will contravene securities law. It’s that simple. Something might be perfectly legal, normal and commonplace under an insurance umbrella, but it can land you in jail in the securities world. I will return to this matter again, in the final Chap. 10.

What all of this implies is that for now we are left with the simple version of the modern tontine in which investors should be pooled with others who are similar in age so that they can all receive the same dividend payouts without (too) much redistribution from those who are older (and might invest more) to those who are younger (and might invest less). Of course, it remains to be seen what happens when the sponsor of a modern tontine announces to the world that anyone between the age of x _low and x _high are welcome to join the pool, regardless of gender. Only time will tell.