Den katolska kyrkans kulturkrig

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-168004"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="1720" data-tin="1911" data-pid="168004" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="RGVuIGthdG9sc2thIGt5cmthbnMga3VsdHVya3JpZw==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xNS0yNi1kZW4ta2F0b2xza2Eta3lya2Fucy1rdWx0dXJrcmlnLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTUtMjYtZGVuLWthdG9sc2thLWt5cmthbnMta3VsdHVya3JpZy5tcDM=">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: "><div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-katolska-kyrkans-kulturkrig%2F&amp;t=Den+katolska+kyrkans+kulturkrig"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Den+katolska+kyrkans+kulturkrig+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-katolska-kyrkans-kulturkrig%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-katolska-kyrkans-kulturkrig%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den katolska kyrkans kulturkrig&body=https://kvartal.se/artiklar/den-katolska-kyrkans-kulturkrig/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/168004/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo&nbsp;Lappin</a> | 22 februari 2025<div class="author-desc">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-katolska-kyrkans-kulturkrig%2F&amp;t=Den+katolska+kyrkans+kulturkrig"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Den+katolska+kyrkans+kulturkrig+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-katolska-kyrkans-kulturkrig%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-katolska-kyrkans-kulturkrig%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den katolska kyrkans kulturkrig&body=https://kvartal.se/artiklar/den-katolska-kyrkans-kulturkrig/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/168004/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/den-katolska-kyrkans-kulturkrig/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 17 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/658eaec0-e4a7-4f0a-a2f2-7da89fbc834c"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-168004">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "168004"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Katoliker har aldrig förr haft ett sådant inflytande över amerikansk politik.</p>
<p>Sex av nio domare i USA:s högsta domstol är nu katoliker. Ytterligare en är uppvuxen katolik. Flera nyckelroller i <strong>Donald Trumps</strong> nya administration innehas av katoliker, bland andra utrikesministern <strong>Marco Rubio</strong>, CIA-direktören <strong>John Ratcliffe</strong> samt <strong>Robert F Kennedy Jr</strong>.</p>
</div>
<div class="rest-of-article ">
<p>Vicepresidenten <strong>JD Vance</strong> är dessutom konvertit till katolicismen, och hans nyfunna religiösa hemvist präglar hans politiska vision.</p>
<p>Men samtidigt som katoliker vunnit politisk mark har politiken sipprat in i den katolska kyrkan. Resultatet har blivit ett kulturkrig med internationella verkningar – som nu påven själv dragits in i.</p>
<h2>USA:s konservativa katolska våg skakar världen</h2>
<p>Ämnet är så kittlande att årets bästa politiska thriller söker sig till Vatikanen och inte Vita huset. <strong>Edward Bergers </strong>film <em>Konklaven</em> (2024) handlar om efterdyningarna till påvens död, där alla kardinaler samlas (i en så kallad konklav) för att rösta fram en efterträdare. Den Oscarstippade skådespelaren <strong>Ralph Fiennes</strong>, klädd i purpurskrud, spelar en kardinal som tvingas navigera hemlighetsmakeri och machiavelliska intriger.</p>
<p><em>Konklaven</em> blir ännu mer aktuell i och med att påve <strong>Franciskus</strong>, 88 år, blivit allvarligt sjuk, och i skrivande stund vårdas på sjukhus. Det har redan börjat spekuleras kring vilket av de två lägren som skulle lyckas rösta in en av sina kandidater om och när påven går bort.</p>
<p>Det finns alltså sämre ställen att börja på för att försöka förstå spänningarna som präglar den amerikanska kyrkan. Kardinalerna i den fiktiva <em>Konklaven</em> är splittrade i två läger. Den ena leds av den bombastiska <strong>Goffredo Tedesco</strong>, en konservativ kardinal som är trött på kyrkans ständiga eftergifter till samtiden. I spetsen för det liberala lägret är italiensk-amerikanen <strong>Aldo Bellini</strong> (<strong>Stanley Tucci</strong>), som har progressiva åsikter i fråga om samkönade äktenskap, skilsmässa och kvinnors roll i kyrkans hierarki. Men hans allra främsta mål är att hindra Tedescos konservativa falang från att komma till makt. När Fiennes karaktär invänder att detta är en konklav och inte ett krig, svarar han uppbragt: ”Det <em>är </em>ett krig.”</p>
<p>Och det är ett slags krig som pågår inom den amerikanska kyrkan, i verkligheten. Skyttegravarna liknar mer eller mindre skiljelinjerna i filmen. Kardinal Tedesco görs visserligen till en italienare i ett försök att blanda ihop korten, men det är uppenbart att det är den amerikanska situationen som står som inspiration. (Tedesco är dessutom en inte speciellt subtil karikatyr av den Trumpvänlige kardinalen <strong>Raymond Burke</strong>, en av påve Franciskus mest högljudda kritiker.)</p>
<h2>Den verklige Franciskus är både gal och tan</h2>
<p>Ett kulturkrig mellan progressiva och konservativa, alltså. Inget nytt under solen.</p>
<p>Trots det är det något lite speciellt med gränsdragningarna idag. Den engelske munken och teologen <strong>Timothy Radcliffe</strong> skrev 2005 att han alltid ryggar tillbaka när han får frågan om huruvida någon är ”liberal” eller ”konservativ” i kyrkliga sammanhang. Det är lite som att fråga någon huruvida de har slutat slå sin hustru än, skrev han. Progressiv och konservativ är vanskliga kategorier att tillämpa på kyrkan.</p>
<p>Anledningen till detta är att kristendomen skär igenom den traditionella politiska höger-vänsterskalan. Ta exempelvis filmen <em>De två påvarna</em> (2019), ett porträtt av <strong>Franciskus</strong> och hans företrädare <strong>Benediktus XVI, </strong>även känd som <strong>Joseph Ratzinger</strong>. Benediktus avgick från påveämbetet 2013 (senaste gången något sådant hände var för 600 år sedan); resultatet var en rätt unik situation där det fanns två ”påvar” i Rom på samma gång, vars relation filmen fiktionaliserar kring. Franciskus och Benediktus får personifiera varsin politisk falang, progressiv respektive bakåtsträvande.</p>
<p>I viss mån motsvarar denna kontrast olikheter i temperament. Benedictus XVI, en varsam bayersk intellektuell, började sin karriär som en progressivt sinnad teolog men avskräcktes av studentrevolterna 1968. Han iklädde sig då rollen av en konservativ motvikt till det han uppfattade som ett Europa vars värderingar urholkats.</p>
<p>I och med Franciskus har påveämbetet sökt sig bortom Europa och till ”periferierna”. Eftersom kyrkans europeiska centrum har stelnat vill Franciskus leta sig till utkanterna, där han menar att den Helige Andens förnyande kraft är som mest närvarande. Tonvikten har fallit på kyrkans sociallära och arbetet med de fattiga i världens ekonomiska ”periferier”. Franciskus skräder inte orden; han kallar ohämmad kapitalism ”avgudadyrkan” och ”djävulens skit”, nyliberalism ”vidskepelse” och ”magiskt tänkande”.</p>
<p>Men bilden är mer komplicerad än filmer som <em>De två påvarna </em>ger sken av. Benediktus var exempelvis lika kategorisk i sina uttalanden om kapitalismen: det är ett ”grymt” system som ”reducerar människor till bytesvaror”, som avslöjar ett ”själviskt och individualistiskt tankesätt”.<sup>1</sup> Han slogs för skuldsanering för tredje världen<sup>2</sup> och fick smeknamnet ”den gröna påven” för sitt engagemang för kraftfullare miljölagar.<sup>3</sup></p>
<p>Franciskus, å sin sida, motbevisar gång på gång bilden av den liberala medie-<em>darling</em> som han upphöjdes till i början. Vid upprepade tillfällen har påven jämfört abort med mord och abortläkare med lönnmördare.<sup>4</sup> Han kallar ”genusideologi” för den ”värsta faran idag”.<sup>5</sup> Hans uttalanden om kvinnor har väckt starka känslor, senast på ett anförande till Katolska universitet i belgiska Louvain när påven beskrev ”kvinnlighet” som en ”vårdande och livgivande kallelse” och menade att kvinnor inte bör försöka efterapa manlighet.<sup>6</sup></p>
<p>De två påvarna visar på varsitt sätt att motpolerna liberal/konservativ eller höger/vänster är svåra att applicera på den kyrkliga politiken.</p>
<h2>JD Vance mot påven</h2>
<p>Eller åtminstone <em>var </em>svåra att applicera – eftersom den rådande situationen i USA motbevisar Timothy Radcliffes tes. Under de senaste decennierna har två block utkristalliserats i kyrkan. Dessa är misstänkt lika skillnaden mellan republikaner och demokrater.</p>
<p>Spänningarna mellan dessa två block trappades upp under <strong>Joe Bidens</strong> tid i Vita huset. Den avgående presidenten var praktiserande katolik – den första katolska presidenten efter <strong>John F Kennedy</strong>, som i sin tur var den första någonsin.</p>
<p>Biden var en regelbunden kyrkobesökare, något som dock blev anledning till turbulens under hans tid som president. På grund av Bidens uttalade stöd till abort fanns det röster som uppmanade präster att neka Biden rätt till nattvarden. För katoliker är nattvarden Jesu verkliga kött och blod; kritiker menade att presidenten inte borde få ta emot nattvarden så länge han företräder politik som går på tvärs mot kyrkans undervisning.</p>
<p>Amerikanska biskopskonferensen röstade om att skriva ett dokument rörande hur politiker som står i konflikt med kyrkans hållning borde förhålla sig till nattvarden, trots att både påven och Vatikanen explicit motsatte sig det. 73 procent röstade för, något som uppfattades som en seger från konservativt håll. När dokumentet väl såg dagens ljus nämndes dock inte Biden eller någon annan politiker vid namn.</p>
<p>Men nu är det konservativa som har direkt politisk påverkan, delvis hjälpt av en högersväng bland amerikanska katoliker. 2008 var 4 av 10 vita katoliker republikaner; idag är motsvarande siffra 6 av 10.<sup>7</sup> (Bland latinamerikanska katoliker ligger siffran stabilt på 60 procent demokratiska väljare.)<sup>8</sup></p>
<blockquote><p>Missnöje mot den nuvarande påven sjuder på flera håll i världen.</p></blockquote>
<p>Högervågen bland katoliker har funnit en företrädare för deras sak i vicepresidenten JD Vance. Det är en öppen fråga hur mycket hans åsikter har formats av katolicismen. Han har dock ett flertal gånger åberopat katolska tankefigurer, inte minst för att gå till angrepp mot USA:s katolska biskopar.</p>
<p>I sin första intervju som vicepresident berättar Vance hur han blev ”hjärtekrossad” när de amerikanska biskoparna offentligt fördömde den nya regeringens linje i fråga om migration och deportation. Han uppmanar biskoparna att ”ta en titt i spegeln” och anklagar dem för att ”inte ha varit en bra partner för en förnuftig migrationspolitik”.<sup>9</sup></p>
<p>Vance fortsatte att utveckla detta spår i en senare intervju med <em>Fox News.</em> ”En väldigt kristen tanke”, hävdar Vance, är att ”man först älskar sin familj, sedan sina grannar, sedan ens sociala gemenskap, sedan ens land och sedan, till slut, kan man fokusera på resten av världen”.<sup>10</sup> Vance förankrar detta i kyrkofadern <strong>Augustinus </strong>(354–430) lära om ”kärlekens ordning” (<em>ordo amoris</em>), det vill säga att man har starkare plikter gentemot dem som är närmast en själv.</p>
<h2>Påven: Den starkes rätt är inte sanningen</h2>
<p>I ett ytterst ovanligt drag gick påve Franciskus ut i ett genmäle. I ett officiellt brev till biskoparna i USA bemöter påven Vances tolkning av den katolska läran, trots att han inte nämner vicepresidenten vid namn. Påven skriver att den sanna meningen av <em>ordo amoris</em> visar sig när man mediterar på berättelsen om den Goda Samariten och ”kärleken som bygger upp ett syskonskap öppen för alla, utan undantag”.<sup>11</sup> Där svarar Jesus på frågan om ”vem är min nästa?” genom att berätta en liknelse om en judisk man som ligger misshandlad vid vägkanten; han räddas varken av en rabbin eller en levit som går förbi, utan slutligen av en samarit, ett folkslag som var fiende med judarna.</p>
<p>”Att i stället bekymra sig om personliga, sociala eller nationella identiteter”, skriver påven, ”mynnar ut i en ideologi som förvränger det samhälleliga livet och påtvingar den starkes rätt som det enda kriteriet för sanning”.</p>
<p>Vances ställningstaganden i teologiska frågor ger fog att tro att vicepresidenten kommer försöka påverka valet av nästa påve. Som det ser ut nu består konklaven till 80 procent av kardinaler som Franciskus själv utnämnt (111 av 141), så det troligaste är en efterträdare i Franciskus anda. Men missnöje mot den nuvarande påven sjuder på flera håll i världen, främst i USA och den anglosaxiska världen, och det finns flera heta konservativa kandidater, däribland ungraren<strong> Péter Erdő </strong>och nederländaren <strong>Willem Eijk</strong>.</p>
<p>Oenigheten mellan påven och Vance är bara höjdpunkten av en upptrappning som länge pågått inom katolska kyrkan i USA.</p>
<p>Precis som det amerikanska kulturkriget lyckas sippra in i varje aspekt av det amerikanska samhället, från bilmärken till glass, letar den sig också in i kyrkorummet. Hit hör frågor om vilken musik och vilket språk som hör hemma i katolska mässor, vilket kan verka långt borta från politikens frontlinjer.</p>
<p>Det mest påfallande exemplet på detta är frågan om den så kallade ”traditionella mässan”, som firades i alla världens hörn fram till 1969. Konservativa katoliker pekar ut 60-talet som tidpunkten då allting började knaka i fogarna och menar att reformerna som genomfördes gav för stora eftergifter till samtiden. Som konsekvens av detta har en stor grupp katoliker sökt sig tillbaka till den traditionella mässan. De kallar sig därför ”traditionalister” – eller ”traddar” – eftersom de säger sig vilja slå vakt om kyrkans tradition.</p>
<blockquote><p>Joseph Strickland hävdade att Vatikanen, liksom USA, har en ”<em>deep state</em>”.</p></blockquote>
<p>Få traddar kan rimligen komma ihåg tridentinska mässans glansdagar, med tanke på att den nya riten trädde i kraft för femtiosex år sedan. Det är snarare den yngre generationen som lockas av traditionalismen. Traddar är ofta millennials och generation Z, uppvuxna i en liberal och sekulär kultur, där stränga moralkoder och traditionella könsroller framstår som något lockande radikalt och subversivt.</p>
<p>Den gamla mässans högtidliga förmoderna dräkt – med latin och rökelse, pompa och ståt – gör den till den perfekta estetiska symbolen för motstånd mot den moderna världen, i kontrast till den nya mässans avskalade form. Ut med gitarrerna, in med gregoriansk sång och dödsmässor. Ut med kvinnliga kyrkotjänare, in med långa kjolar och hårtäckande sjalar.<em> </em></p>
<p><em>Trad </em>är det nya hipster. Eller som <em>New York Times</em> uttryckte det: katolska kyrkan har blivit den ”coolaste klubben i stan” (där stan i fråga är New York).</p>
<p>På många håll i USA har denna rörelse lett till en blomstring och det som – om kyrkan hade varit frikyrkligt lagt – hade kunnat kallas ”väckelse”. Men kulturkriget har också lett till splittring och sekteristiska utspel.</p>
<h2>Nu blir det andra bullor</h2>
<p>Påve Franciskus satte till slut ner foten och begränsade bruket av den traditionella mässan, med hänvisning till dess roll i splittringar inom kyrkan. Mässan är inte strängt taget förbjuden, men det är upp till varje biskop som vill tillåta den i sitt stift att ta reda på huruvida grupper som firar mässan menar att det är den enda giltiga gudstjänstformen.<sup>12</sup> Biskopen måste sedan ansöka om ett särskilt tillstånd från Vatikanen.</p>
<p>Nu var påven inte speciellt populär bland traddarna till att börja med, men inskränkningen av den gamla riten blev droppen som fick bägaren att rinna över. <strong>Joseph Strickland</strong>, dåvarande biskop i Tyler, Texas, gick till motangrepp och hävdade att Vatikanen, liksom USA, har en ”<em>deep state</em>”, där Franciskus drar i trådarna för att undergräva tron.<sup>13</sup> Efter att Vatikanen inledde en undersökning kring Stricklands ledarskap av stiftet blev han avsatt från sin roll som biskop. Andra i den traditionalistiska rörelsen intog ännu mer radikala positioner; den inflytelserika kommentatorn <strong>Patrick Coffin</strong> menar exempelvis att Franciskus inte är den riktiga påven och att påveämbetet i själva verket är ”vakant” (en position känd under det latinska namnet <em>sede vacante</em>, en slags teologisk motsvarighet till Trumps påstående om fusk under valet 2020).<sup>14</sup></p>
<p>Det dröjde inte länge innan Franciskus gav svar på tal. Påven förklarade att hans motståndare har en ”självmordsbenägen attityd” och låser in sig i en ”dogmatisk låda”.<sup>15</sup> I en intervju med jesuiter i Portugal 2023 beskrev påven den amerikanska kyrkan som ”bakåtsträvande” och präglad av en ”mycket stark reaktionär attityd” och en ”stel och förvriden” mentalitet, där man vänder sig till ideologi snarare än att leva i tron.<sup>16</sup></p>
<p>Sammandrabbningen mellan påven och Vance är alltså bara kulmen på kriget mellan traddarna och liberala katoliker. Och det finns liberala katoliker i USA, även i politiken, där Biden är bara ett av många exempel.</p>
<p>Trots att de inte är lika högljudda som sina konservativa motparter är de ”liberala” katolikerna majoriteten i statistiken. I fråga om påven – traddarnas favoritmåltavla – är 75 procent av katolikerna positivt inställda till Franciskus. Visserligen har denna siffra sjunkit från 90 procent när han valdes 2015 och från 83 procent 2021, men det är ändå en stabil majoritet. Det finns också ett växande glapp mellan demokratiska och republikanska väljare. 9 av 10 demokrater är positivt inställda, men bara 63 procent av republikanerna.<sup>17</sup> Den allmänna känslan bland republikaner summeras av den konservativa techmiljärdären <strong>Peter Thiel</strong>, som själv inte är katolik, något som han rättfärdigar med ett ”tvåordigt argument”: ”Påve Franciskus”.</p>
<p>Men statistiken visar också en annan sida av amerikansk katolicism, en som skaver med bilden av en konservativ kyrka som släpar fötterna gentemot påvens reformistiska linje. Katolska kyrkans lära slår exempelvis fast att abort är fel, men 6 av 10 amerikanska katoliker menar att abort ska vara laglig i alla eller de flesta fall.<sup>18</sup> Kyrkan tycker att preventivmedel är fel; det gör inte 89 procent av amerikanska katoliker.<sup>19</sup> Kyrkan är emot samkönade äktenskap, något som 61 procent av amerikanska katoliker var positivt inställda till 2019.<sup>20</sup></p>
<p>I dessa frågor verkar det snarare som att gemene katolik är mer liberal än påven, inte tvärtom.</p>
<p>Hur förklarar man då den traditionalistiska vågen?</p>
<p>Några pekar på att Franciskus mest tilltalar katoliker som ändå inte går till kyrkan eller bryr sig speciellt mycket över huvud taget. De katoliker som ofta går i kyrkan befinner sig ofta just på den konservativa delen av spektrumet. Denna tes har framförts av <strong>Ross Douthat</strong>, ledarskribent i <em>New York Times</em> och uttalad Franciskuskritiker. Lägg till det faktum att bland nya unga präster som vigs i USA är 85 procent politiskt konservativa. Då verkar Douthats spådomar om att Franciskus vision inte kommer få fäste i Amerika inte så orimliga.</p>
<p>En annan förklaring är att dessa (ofta unga) grupper har en stark internetnärvaro. Trots ett statistiskt underläge får det traditionalistiska lägret förstärkning av en flora av bloggar, poddar, Youtube-kanaler och dylikt, som lockar till sig följarskaror oavsett geografisk förankring.</p>
<p>Det är denna nätmiljö som tycks ha fostrat JD Vances omvändelse till katolicismen. Floran av poddar och nättidskrifter har möjliggjort en ny våg av katolskt politiskt tänkande, i synnerhet från konservativt håll. En stjärna på den himlen är den katolske politiska filosofen <strong>Patrick Deneen </strong>och hans ”postliberalism”.</p>
<h2>Låt en aristokrati med katolska dygder styra</h2>
<p>Patrick Deneen, verksam vid det katolska universitetet Notre Dame du Lac i Indiana, slog igenom med boken <em>Why liberalism failed</em> (2018), som rekommenderades av <strong>Barack Obama </strong>som nödvändig läsning för att förstå Demokraternas magplask i valet 2016. Denna bok skrevs enligt Deneens egen utsaga <em>innan</em> Donald Trumps överraskande valseger.</p>
<p>Kärnan i Deneens argument är att liberalismen är en centrifugalkraft som – i jämlikhetens namn – skapar de största ekonomiska klyftorna mellan vinnare och förlorare som världen någonsin skådat. Liberalismen skapar också ”moraliska” klyftor, genom att pådyvla sin falska bild av frihet som frihet <em>från normer</em>; detta har slagit hårdast mot de grupper som traditionellt mest varit i behov av ett ramverk och normer, det vill säga arbetarklassen, som är överrepresenterad i statistik rörande skilsmässa, utomäktenskapliga barn och knarkbrott. Deneen identifierar dessa två aspekter av liberalismen som <em>ekonomisk </em>liberalism (motsvarande den ”klassiska liberalismen” med tänkare som <strong>John Locke </strong>och <strong>Adam Smith</strong>) respektive <em>progressiv</em> liberalism (representerad av exempelvis <strong>John Stuart Mills</strong> attack mot traditionell sedvänja). Dessa två frihetsideologier motsvarar dessutom det  republikanska respektive demokratiska partiet. Under de två amerikanska partiernas skillnader menar Deneen att det gömmer sig en djupare filosofisk samstämmighet.</p>
<p>Det blir då ett jobbigt läge om man, som Deneen, motsätter sig såväl den ekonomiska liberalismen (som han menar har förstört såväl vår kultur som vår natur) som den progressiva. Resultatet blir då en slags ”politisk hemlöshet” för dem som ser sig som både ekonomiskt vänster och värderingskonservativa, som Deneen uttrycker det i en intervju.<sup>21</sup></p>
<p>Deneen verkar ha utövat ett visst inflytande på JD Vances politiska vision, inte minst den katolska blandningen av ekonomiskt vänster och värdekonservatism. Vance är fjärran från den klassiska libertariansk-anstrukna Reagankonservatism som har varit dominerande i Republikanerna. I en intervju på <em>Fox News</em> från 2021 hävdar Vance att man borde ”beslagta <em>Ford Foundations</em> tillgångar” och fördela dem till de människor vars liv har krossats av den ”radikala öppna gränser-agendan”.<sup>22</sup></p>
<p>I en essä från 2020 om hans konversion till katolicismen med titeln <em>How I joined the resistance</em>, publicerad i den katolska tidskriften <em>The Lamp</em>, beskriver Vance hur det var just katolicismen som öppnade hans ögon för hur man kunde få ihop hans missnöje med det rådande ekonomiska tänkandet med en allmänt konservativ världsbild.</p>
<p>I Vances bok <em>Hillbilly elegy</em> (2016), till hälften memoar och hälften social kommentar om Vances uppväxt i den ekonomiskt utsatta Appalachia, kände han sig missnöjd med båda de rådande analyserna av situationen i regionen. Från högerhåll var lösningen att Appalachiaborna borde skärpa sig och själva ta ansvar för att resa sig ur fattigdom. För Vance kändes detta ”hjärtlöst”, men analyserna från vänstern osade av ”kapitulation”. Genom att uteslutande fokusera på de sociala faktorerna riskerade man att göra invånarna till offer utan egen vilja.</p>
<p>Det som till slut fick det att gå ihop var Vances möte med katolicismen. Katolicismen, skriver Vance, är ”besatt av dygden, men medveten om att dygd formas inom kontexten av den bredare sociala gemenskapen; som har medlidande med världens svaga och fattiga men utan att behandla dem som offer; skyddande av barn och familjer och allt som är nödvändigt för de att blomstra”.<sup>23</sup></p>
<blockquote><p>Han kallar sin egen vision ”aristopopulism”, det vill säga en blandning av folkstyre (populism) och en dygdig elit som administrerar staten.</p></blockquote>
<p>Rörelsen som nu tar fart verkar råda bot på Deneens känsla av hemlöshet. Deneen verkar nu övertygad om att det finns ett hem för ett sådant projekt, åtminstone av hans senaste bok <em>Regime change</em> (2024) att döma. Det är på intet sätt ett perfekt hem, medger han, den är ”dåligt styrd” av en ”djupt bristfällig narcissist”. Medan den tidigare boken präglas av en slags uppgivenhet över att liberalismen hade lyckats sippra in i alla skrymslen och vrån, så genomsyras <em>Regime change</em> av en revolutionär iver.</p>
<p>Deneens analys följer en vanlig trop i samtida politisk teori, att populismen har uppstått på grund av en allt starkare stratifiering mellan ”eliter” och ”folket”, de ”få” och de ”många”. En liberal elit har påtvingat sina värderingar utan hänsyn till folkets vilja eller folkets bästa. Deneen menar att de olika lägren i den nya klasskampen intar den ena partens sida och attackerar förmenta brister hos den andra parten (folkets förkämpar pekar på eliternas korruption och hyckleri, eliterna fokuserar på folkets rasism och brist på god sed). Deneen vill i stället forma en vision som fokuserar på det ”gemensamma goda” för båda parter.</p>
<p>Här ställer sig Deneen i en tradition av det som kallas för katolsk sociallära, som påbörjades av påve<strong> Leo XIII </strong>1891. Leo XIII:s ansats var att förena marxismen och arbetarrörelsen med kapitalismen, för att läka klasskampen och föreslå en organisk vision för hela samhällskroppen. Deneen försöker sig på något liknande, men nu i förhållande till klasskampen mellan det konservativa folket och en progressiv elit. Han kallar sin egen vision ”aristopopulism”, det vill säga en blandning av folkstyre (populism) och en dygdig elit som administrerar staten med folkets bästa i åtanke (aristokrati). Deneens ideala härskarklass kommer att vara ”en elit <em>för </em>folket och <em>mot</em> den progressiva eliten”. Den nya eliten kommer bestå av personer som har en fot i båda världar, som känner folket väl och kan föra dess talan, men som också har studerat på elituniversitet och kan navigera maktens korridorer – kort sagt, personer som liknar… JD Vance?</p>
<p><a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="168004">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1, <a href="https://www.bbc.com/news/world-europe-20882894">https://www.bbc.com/news/world-europe-20882894</a></p>
<p><a href="#_ftnref2" name="_ftn2"></a><span style="font-size: 13.3333px;">2, </span><a href="https://www.asianews.it/news-en/Time-to-cancel-poor-countries-debt,-says-Vatican-7686.html">https://www.asianews.it/news-en/Time-to-cancel-poor-countries-debt,-says-Vatican-7686.html</a></p>
<p>3, <a href="https://www.newsweek.com/benedict-xvi-green-pope-86391">https://www.newsweek.com/benedict-xvi-green-pope-86391</a></p>
<p><span style="font-size: 13.3333px;">4,</span> <a href="https://www.lemonde.fr/en/international/article/2024/10/17/in-belgium-the-pope-calling-abortion-doctors-hitmen-sparks-a-wave-of-debaptisms_6729696_4.html#:~:text=By%20denouncing%20a%20'criminal%20law,Pope%20Francis%20drew%20sharp%20criticism.&amp;text=Leaving%20for%20Rome%20on%20September,doctors%20%E2%80%93%20to%20carry%20out%20abortions">https://www.lemonde.fr/en/international/article/2024/10/17/in-belgium-the-pope-calling-abortion-doctors-hitmen-sparks-a-wave-of-debaptisms</a></p>
<p><a href="#_ftnref5" name="_ftn5"></a>5, <a href="https://www.ewtnvatican.com/articles/catholic-churchs-stand-on-gender-ideology-pope-francis-and-theologians-speak-out-2973">https://www.ewtnvatican.com/articles/catholic-churchs-stand-on-gender-ideology-pope-francis-and-theologians-speak-out-2973</a></p>
<p>6, <a href="https://www.theguardian.com/world/2024/sep/29/catholic-belgian-university-deplores-comments-by-pope-francis-moments-after-speech">https://www.theguardian.com/world/2024/sep/29/catholic-belgian-university-deplores-comments-by-pope-francis-moments-after-speech</a></p>
<p>7, https://www.pewresearch.org/politics/2020/06/02/democratic-edge-in-party-identification-narrows-slightly/#religious-divides-in-partisanship</p>
<p>8, <a href="https://www.pewresearch.org/short-reads/2020/09/15/8-facts-about-catholics-and-politics-in-the-u-s/">https://www.pewresearch.org/short-reads/2020/09/15/8-facts-about-catholics-and-politics-in-the-u-s/</a></p>
<p><a href="#_ftnref9" name="_ftn9"></a><span style="font-size: 13.3333px;">9, </span><a href="https://www.cbsnews.com/news/jd-vance-transcript-face-the-nation-01-26-2025/">https://www.cbsnews.com/news/jd-vance-transcript-face-the-nation-01-26-2025/</a></p>
<p>10, <a href="https://www.youtube.com/watch?v=o98Po0lWZxE&amp;t=274s">https://www.youtube.com/watch?v=o98Po0lWZxE&amp;t=274s</a></p>
<p>11, <a href="https://www.vatican.va/content/francesco/en/letters/2025/documents/20250210-lettera-vescovi-usa.html">https://www.vatican.va/content/francesco/en/letters/2025/documents/20250210-lettera-vescovi-usa.html</a></p>
<p>12, <a href="https://www.americamagazine.org/faith/2021/07/16/pope-francis-decree-restricts-pre-vatican-ii-latin-mass-241068"> https://www.americamagazine.org/faith/2021/07/16/pope-francis-decree-restricts-pre-vatican-ii-latin-mass-241068</a></p>
<p>13, <a href="https://www.catholicnewsagency.com/news/256218/bishop-strickland-was-advised-to-leave-tyler-diocese-but-can-still-say-mass-there">https://www.catholicnewsagency.com/news/256218/bishop-strickland-was-advised-to-leave-tyler-diocese-but-can-still-say-mass-there</a></p>
<p>14, <a href="https://www.patrickcoffin.media/seven-pieces-of-evidence-that-francis-is-an-antipope/">https://www.patrickcoffin.media/seven-pieces-of-evidence-that-francis-is-an-antipope/</a></p>
<p>15, <a href="https://www.catholicnewsagency.com/news/257718/pope-francis-says-conservative-critics-have-a-suicidal-attitude">https://www.catholicnewsagency.com/news/257718/pope-francis-says-conservative-critics-have-a-suicidal-attitude</a></p>
<p>16, <a href="https://catholicoutlook.org/the-water-has-been-agitated-francis-in-conversation-with-jesuits-in-portugal/">https://catholicoutlook.org/the-water-has-been-agitated-francis-in-conversation-with-jesuits-in-portugal/</a></p>
<p>17, <a href="https://www.pewresearch.org/religion/2024/04/12/majority-of-u-s-catholics-express-favorable-view-of-pope-francis/">https://www.pewresearch.org/religion/2024/04/12/majority-of-u-s-catholics-express-favorable-view-of-pope-francis/</a></p>
<p>18, <a href="https://www.npr.org/2024/04/12/1244156165/abortion-catholics-pope-francis-church-pew-research">https://www.npr.org/2024/04/12/1244156165/abortion-catholics-pope-francis-church-pew-research</a></p>
<p>19, <a href="https://www.americamagazine.org/faith/2016/09/28/poll-finds-many-us-catholics-breaking-church-over-contraception-abortion-and-lgbt">https://www.americamagazine.org/faith/2016/09/28/poll-finds-many-us-catholics-breaking-church-over-contraception-abortion-and-lgbt</a></p>
<p><a href="#_ftnref20" name="_ftn20"></a>20, <a href="https://www.pewresearch.org/politics/2019/05/14/majority-of-public-favors-same-sex-marriage-but-divisions-persist/">https://www.pewresearch.org/politics/2019/05/14/majority-of-public-favors-same-sex-marriage-but-divisions-persist/</a></p>
<p>21, <a href="https://www.nytimes.com/2021/10/19/magazine/viktor-orban-rod-dreher.html">https://www.nytimes.com/2021/10/19/magazine/viktor-orban-rod-dreher.html</a></p>
<p>22,  <a href="https://www.youtube.com/watch?v=-VltncxBc3k">https://www.youtube.com/watch?v=-VltncxBc3k</a></p>
<p>23,<a href="#_ftnref23" name="_ftn23"></a> <a href="https://thelampmagazine.com/blog/how-i-joined-the-resistance">https://thelampmagazine.com/blog/how-i-joined-the-resistance</a></p>
</div>
</div>
<div class="author-byline">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>
</div>
