
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Out-of-Control Public Deficits</h3><h4>12 April 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>Deficits are out of control, and the real story is that there’s no mechanism for bringing them under control.<em>"</em></p><p>Jim Cielinski, Head of Fixed Income, Janus Henderson</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='out-of-control-public-deficits' href='/Content/Downloads/ARP/ARP240412.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/66194ed2fdaae7c0b005bea0_iStock-1462684847_705x414.jpg#236;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#363;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#363;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#363;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#363;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>In preparation for this paper, I googled &ldquo;Out-of-Control Public Deficits&rdquo;, and the first three stories that popped up on my screen were:</p>

<p><a href="https://www.euronews.com/business/2023/10/03/3-trillion-is-frances-debt-out-of-control">&euro;3 trillion: Is France&#39;s debt out of control? </a></p>

<p><a href="https://www.ft.com/content/33f85fd6-55ec-45a1-a1b6-69a845726d58">Investors warn governments about high levels of public debt</a></p>

<p><a href="https://www.lemonde.fr/en/economy/article/2024/02/22/the-wall-of-public-debt-that-americans-do-not-want-to-see_6547822_19.html">The wall of public debt that Americans do not want to see</a></p>

<p>Frankly, for a while, I have worried about the escalating levels of public debt, but I didn&rsquo;t realise it has become frontpage news all over the world. For fear of being late to the party, my first reaction was to drop my plans to write about it; however, the topic is too important to ignore, so here we go.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Global government net debt, % of GDP</strong><br />
<em>Source: </em><a href="https://www.ft.com/content/33f85fd6-55ec-45a1-a1b6-69a845726d58"><em>Financial Times</em></a></p>
' data-image='/Content/Images/66194fa66cbcd6ed041a861b_Picture2.png#364;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: Net supply of US Treasuries, $Tn</strong><br />
<em>Source: </em><a href="https://www.ft.com/content/33f85fd6-55ec-45a1-a1b6-69a845726d58"><em>Financial Times</em></a></p>
' data-image2= '/Content/Images/66194fecfa637556c45ceae8_Picture3.png#364;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 3: US interest expenses vs. interest rates </strong><br />
<em>Sources: The Daily Shot, Oxford Economics</em></p>
' data-image3= '/Content/Images/6619505188cb457778ef4c5d_Picture4.png#364;slide-image3;;' data-image4= '/Content/Images/6619509ede5229e80515f2d7_Picture5.png#364;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The latest on public debt</h4><p>My concerns are probably best illustrated in Exhibit 1 below. As you can see, bar the post-pandemic correction, government debt continues to tick up and is now almost 100% of global GDP. It is as if governments all over the world have lost all sanity and now appear to subscribe to the thesis promoted by subscribers to Modern Monetary Theory (MMT) that governments can, without consequences, take on virtually endless amounts of debt.</p>

<p>--image--</p>

<p>I shall not spend much time on MMT today other than saying that, if you believe in MMT, you would probably do better by believing in Father Christmas. At least, it will provide some entertainment in the family. On a more serious note, I suggest you read <a href="https://bipartisanpolicy.org/blog/does-the-national-debt-matter-a-look-at-modern-monetary-theory/">this </a>for a sober critique of MMT.</p>

<p>In recent years, governments have been able to take on vast amounts of debt at virtually no cost but that is no longer the case &ndash; free money is no longer. Take for example the US Treasury. According to Apollo Global Management, in 2024, it is expected to issue around $4Tn of new bonds &ndash; up from $3Tn last year. Net issuance, i.e. new bonds less debt falling due, should exceed $1.5Tn this year, and that number is expected to be even higher next year (Exhibit 2).</p>

<p>--image2--</p>

<p>For argument&rsquo;s sake, let&rsquo;s assume net issuance of US Treasuries adds up to $1.6Tn this year &ndash; the deficit projected by the Bipartisan Policy Center and in line with the estimate used by Financial Times in Exhibit 2 above. The US Treasury is expected to issue bonds with maturities anywhere from 2 to 30 years, and the cost to the Treasury is projected to be $70-80Bn, assuming current yields don&rsquo;t change much.</p>

<p>In the context of the overall 2024 deficit of $1.6Tn (which is still an estimate), $70-80Bn may not sound like a lot, but it is still a far cry from the cost of issuing debt only a few years ago (Exhibit 3). Adding to that, according to the Bipartisan Policy Center, US government net debt-to-GDP, which is projected to land at 99% in F2024, is expected to rise to 116% over the next ten years. And, if that is today&rsquo;s estimate, as we all know, we will most likely end up with a higher number. (I should point out that, in Exhibit 5 below, US government debt-to-GDP is suggested to be 123%. That is based on <em>gross </em>debt whereas the 99% above is based on <em>net </em>debt.)</p>

<p>--image3--</p>

<p>Although treasurers always argue that they will seek to take advantage of yield curve idiosyncrasies when issuing new debt to reduce the burden on the public P&amp;L as much as possible, as you can see from Exhibit 3, in practice, interest rates and interest expenses move more or less hand in hand.</p>

<p>In the US, it is expected that the government deficit, when measured as a % of GDP, will hover between 6.5% and 8% over the next few years (source: IMF), a sharp increase from less than 4% in 2022. Unless the Americans get the escalating deficit problem under control relatively quickly, the 2035 estimate provided by the Bipartisan Policy Center and referred to earlier (116%) <em>dramatically </em>understates where we will end up in 2035. In that context, it is also worth noting that, in the eurozone, all alarm bells go off if the government deficit is higher than 3% of GDP in a member country.</p>

<p>Talking about Europe, lets switch to France. In the last 20 years, French government debt has risen from &euro;1Tn to &euro;3Tn (source: <a href="https://www.euronews.com/business/2023/10/03/3-trillion-is-frances-debt-out-of-control">euronews.com</a>). This has resulted in a sharp rise in French government debt-to-GDP which is now approaching 115% (Exhibit 4). 15% of all French government debt is held by the European Central Bank (ECB), and they have no interest in creating credibility problems for their member countries, i.e. you should expect the ECB to continue to buy plenty of eurozone government bonds.</p>

<p>--image4--</p>

<p>From looking at the chart above, I note that France is not the only eurozone country being addicted to debt. France is only one of six eurozone countries where debt-to-GDP exceeds 100% now. (When the eurozone was first created, the limit was 60%.) However, unlike some of the other countries, and I am particularly thinking of Greece and Italy, France is still considered trustworthy by the ratings agencies. Greece and Italy are not.</p>

<p>In total, it is projected that the ten largest eurozone countries will issue a combined &euro;1.2Tn of public debt this year with net issuance adding up to &euro;640Bn (+18% &ndash; source: Financial Times). In other words, the Europeans are not light years behind the Americans in sowing the seeds of trouble. Don&rsquo;t get me wrong, running a deficit during economic downturns is a perfectly legitimate economic tool. The problem arises when the economy is firing on most cylinders, as is the case in the US at present. Yet, there is zero desire to reduce the massive deficit.</p>

<p>&nbsp;</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 5: Government debt-to-GDP, 2023 (most indebted countries)</strong><br />
<em>Source: </em><a href="https://www.visualcapitalist.com/government-debt-by-country-advanced-economies/"><em>Visual Capitalist</em></a></p>
' data-image='/Content/Images/661950d53cfb6e2976df1a47_Picture6.png#365;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#365;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#365;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#365;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How will it all end?</h4><p>How is this likely to end? That is admittedly an extraordinarily difficult question. At the end of the day, yields on government bonds are dictated by investors&rsquo; trust in the government&rsquo;s ability to repay. If you, 20 years ago, had predicted that Japanese debt-to-GDP in 2023 would stand at 255%, and that debt-to-GDP in the biggest economy of them all, the US, would be at 123% (Exhibit 5), calamity would have been predicted, but investors appear to be non-fussed.</p>

<p>--image--</p>

<p>They continue to be more worried about inflation than by the government&rsquo;s ability to repay debt. In other words, maybe MMT has left a bigger impression on investors that I find reasonable. Having said that, a few countries have paid a very high price for losing control.</p>

<p>Take for example Argentina. 100 years ago, it was a global powerhouse. It was actually a top-10 country GDP-wise. Years of mismanagement led to the sort of mess the country is in today. Alternatively, look at Greece. We had a near-disaster in Greece not that many years ago. To the poor Greeks, it was in fact not a near-disaster &ndash; it was an unmitigated disaster, a head-on collision. In this case, the rest of Europe came to its rescue (at a price), but the scars are still deep.</p>

<p>I remain convinced that Argentina and Greece won&rsquo;t be the last countries to face humiliation. That said, it is near impossible to predict which one will be the next to fall. Maybe it will be one of the countries on the list in Exhibit 5 &ndash; maybe not. Very hard to say, which makes the investment implications very tricky. As I said, at the end of the day, it is not about how indebted the country in question is. It is about <em>trust</em>.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#366;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#366;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#366;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#366;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Investment implications</h4><p>Times are truly extraordinary. The ongoing commercialisation of AI, the worldwide rollout of obesity drugs aimed at the approx. one billion people being significantly overweight plus the transition away from fossil fuels all lead to many, and very rewarding, investment opportunities. One could even argue that the combination of those three investment themes will not only lead to higher economic growth in the years to come but also to lower public expenditures over time. So far, so good; however, when you then add the public sector&rsquo;s insatiable appetite for debt, the story weakens dramatically.</p>

<p>Given how AI, obesity drugs and the green transition are likely to impact GDP growth positively, it will most likely be a mistake to exit equities altogether. A different strategy shall be warranted, and I would I suggest the following approach.</p>

<p>First and foremost, stay clear of companies that depend on the public sector for a meaningful share of their revenues. The day will arrive &ndash; and I don&rsquo;t think we are far away &ndash; where decision makers in the public sector will be forced to tighten the belt, and the first area to be affected will likely be new investments away from healthcare and social benefits. A cutback on social benefits and/or healthcare will affect many voters dramatically, and few politicians have any appetite for upsetting voters.</p>

<p>Secondly, scrutinise your portfolio and decide what you want to hedge. Equity risk, bond risk or both? Small cap or large cap equities? Any particular geographies? Once this exercise has been completed, search for the best hedging instrument. Before going any further, I should point out that the easy solution is not to invest at all in &lsquo;red flag&rsquo; countries but, given the significant impact of the themes mentioned above, such an investment strategy may not be optimal.</p>

<p>I would use options instead. I would set aside a small percentage of my capital each year (around 0.5-1.0%) and buy out-of-the-money put options on an appropriate index. For example, if most of my portfolio is invested in large cap US stocks, I would buy out-of-the-money put options on the S&amp;P 500. How far out-of-the money?</p>

<p>Recently, I wrote an ARP+ research paper called <em>Demise of the DM Growth Model</em> which you can find <a href="https://www.arpinvestments.com/insights/demise-of-the-dm-growth-model">here</a>. In that paper, you&rsquo;ll find a section about options. Most of the points I made there also apply to this paper. Only one thing would be different. I would operate with a bigger margin of error, i.e. instead of buying put options that are 10-15% out-of-the-money, I would go for 15-20%, possibly even 25%, out-of-the money instead. You are not hedging against the common cold here but against the Spanish flu. These things don&rsquo;t come by every day, and it is important that you don&rsquo;t spend a disproportionate amount of money on hedging.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#367;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#367;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#367;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#367;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final comments</h4><p>Given that we are in a big election year worldwide, many governments, in their desire to seek re-election, will probably continue to close their eyes to all the negative implications of rising indebtedness. Populism has brought many bad things to the political arena in recent years, and rising indebtedness is certainly one of them.</p>

<p>Governments <em>cannot</em>, year after year, continue to raise debt levels and then expect investors just to shrug their shoulders. Something will, sooner or later, have to give. Assume, for example, that Standard &amp; Poors decides to cut the rating on US public debt to A, which would result in a major selloff. That again would likely lead to questions about the USD&rsquo;s reserve currency status and would most likely lead to a massive steepening of the yield curve.</p>

<p>Allow me one final quote today &ndash; this time from Robert Tipp, Head of Global Bonds at PGIM Fixed Income who, in a recent interview with Financial Times stated that <em>&ldquo;we are truly in an unmoored environment for government debt compared with previous centuries. Everyone is getting a pass right now, whether you are in the US or Italy, but there have been some signs recently that investors and rating agencies are starting to think about this again.&rdquo;</em></p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>12 April 2024</strong></p></div></div></div>