Freuds ande svävar över prins Harrys bok

<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-85294"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="85294" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfZnJldWRzX2FuZGVfc3ZhdmFyX292ZXJfcHJpbnNfaGFycnlzX2Jvay5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvZnJldWRzLWFuZGUtc3ZhdmFyLW92ZXItcHJpbnMtaGFycnlzLWJvay5tcDM=">  <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: ">Av <a href="https://kvartal.se/medverkande/billy-larsson/">Billy&nbsp;Larsson</a> | 21 januari 2023<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%2Ffreuds-ande-svavar-over-prins-harrys-bok%2F&amp;t=Freuds+ande+sv%C3%A4var+%C3%B6ver+prins+Harrys+bok"    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=Freuds+ande+sv%C3%A4var+%C3%B6ver+prins+Harrys+bok+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffreuds-ande-svavar-over-prins-harrys-bok%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%2Ffreuds-ande-svavar-over-prins-harrys-bok%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Freuds ande svävar över prins Harrys bok&body=https://kvartal.se/artiklar/freuds-ande-svavar-over-prins-harrys-bok/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/85294/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/85294/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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="kv-art-ext-sep"></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%2Ffreuds-ande-svavar-over-prins-harrys-bok%2F&amp;t=Freuds+ande+sv%C3%A4var+%C3%B6ver+prins+Harrys+bok"    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=Freuds+ande+sv%C3%A4var+%C3%B6ver+prins+Harrys+bok+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffreuds-ande-svavar-over-prins-harrys-bok%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%2Ffreuds-ande-svavar-over-prins-harrys-bok%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Freuds ande svävar över prins Harrys bok&body=https://kvartal.se/artiklar/freuds-ande-svavar-over-prins-harrys-bok/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/85294/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/85294/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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/freuds-ande-svavar-over-prins-harrys-bok/?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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/85294"    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-85294">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "85294"></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 ">Med tanke på att prins Harrys självbiografiska bok <em>Spare</em> säljer i rekordfart lär prinsen vara tacksam för vad spökskrivaren <strong>JR Moehringer</strong> hjälpt honom att åstadkomma. Men prinsen bör nog visa postum tacksamhet mot en person till, nämligen <strong>Sigmund Freud</strong>. Det hänger ihop på följande vis.</p>
</div>
<div class="rest-of-article ">
<p>Att skriva någons självbiografi kräver inte bara talang för att hitta dramatiken i personens liv. Ska man lyckas på bästa vis behövs mer än så, nämligen gedigna förberedelser. Det har Moehringer förstått, som tidigare hjälpt även <strong>Andre Agassi</strong> att få sitt liv i bokform.<sup>1 </sup></p>
<p>Då förberedde sig Moehringer genom att läsa psykologiska giganter som <strong>Freud</strong> och <strong>Adler</strong>. Speciellt användbar fann han Freuds beskrivning av en ”dödsdrift” i <em>Vi vantrivs i kulturen</em>. Den påstås vara en drift till att förstöra allt liv, och visar sig som destruktion mot andra och som självförstörelse. Med hjälp av den driften kunde han tänka att Agassi hade en medfödd självdestruktivitet – en tanke som passade för att arrangera Agassis livshistoria.<sup id="cite_ref-2" class="reference"></sup></p>
<h2>Freud skapade starka och enkla narrativ</h2>
<p>Den tankegången verkar även underlättat för att skapa ett användbart narrativ runt prins Harrys liv, som ju rymmer både framgång, tragik och missbruk som går att tolka som självdestruktivitet. BBC:s recensent noterade att <em>Spare</em> präglas av en närmast besatthet av döden. Till och med på sin brors bröllop i Westminster Abbey går Harrys tankar till de 3 000 människor som begravts i kyrkan genom århundradena. Grundtemat i boken är moderns död, ett trauma som sedan får bli förklaringen till Harrys problem i livet med självdestruktivitet och paralyserande ångest. Denna oförlösta sorg jagar honom ända tills han träffar Meghan, som ger honom den känslomässiga förankring som han har saknat. Det är en stark berättelse. Därav det rimliga med tacksamhet även gentemot Freud.</p>
<p>Av detta finns lärdomar att dra.</p>
<p>Det finns ingen allmänt accepterad uppfattning om hur det kommer sig att vi dör. Molekylärbiologer har förklaringar om hur det blir allt fler skador på celler som i sin tur försämrar organens förmåga, vilket leder till att kroppen till slut lägger av att fungera och döden inträder. Att förklara varför levande varelser dör är således komplext, men inget talar för att det finns en specifik drift som åstadkommer detta. Däremot är tanken på att frivilligt dö en för människan utmärkande kategori.</p>
<p>Vi har en förmåga till framtidsorienterat tänkande som gynnar oss. Men den är tveeggad. När det vi hoppats på i stället blir en motgång, då dyker det lätt upp tankar om hur meningsfullt livet egentligen är, och vid stora motgångar, om att döden kan vara ett bättre alternativ. Och om vi anklagar oss själva när livet inte blir som vi hoppats står självhatet på lur och vi kan bli självdestruktiva – om vi kommit fram till att det inte är mer än rätt åt oss.</p>
<p>Det är alltså människans komplexa sätt att kunna resonera om sig själv som är grunden för självmord och självdestruktivitet, inte en medfödd dödsdrift. Samtidigt har Freud i snart hundra år fascinerat många med sin ofta träffande beskrivning av det mänskliga livet i <em>Vi vantrivs i kulturen</em>. Då har man inte brytt sig om hur orimlig Freuds förklaring är till svårigheten att vara lycklig: ”kulturmänniskan” kan inte ohämmat leva ut sin sexualdrift och aggressionsdrift som den lyckligare ”urmänniskan” kunde, enligt Freud. Och vem är väl mer hämmad än prinsen i sin gyllene bur av hovetikett?</p>
<h2>Stark berättelse trumfar vetenskapen</h2>
<p>För många övertrumfar således Freuds större berättelse om kampen mellan Eros och dödsdriften det faktum att själva teorin inte stämmer. Det vill säga, författaren Freud med sitt levande språk får större lockelse än den moderna forskaren som torrt förklarar varför livet slutar med döden.</p>
<p>Freuds dramatiska berättarkonst bidrar nog till psykoanalysens anseende på kultursidorna. I Svenska Dagbladet skrivs understreckare av psykoanalytikerna <strong>Clarence Crafoord</strong> och <strong>Ulf Karl Olov Nilsson.</strong> I Göteborgs-Posten är psykoanalytikern <strong>Per Magnus Johansson</strong> flitig skribent, och psykoanalytikern <strong>Sinziana Ravini</strong> skriver i såväl GP som Aftonbladet.</p>
<p>Freud är då förstås teoretisk husgud, vanligen följd av psykoanalytikern <strong>Jaques Lacan </strong>(1901–1981). Men även bland kulturskribenter som inte är psykoanalytiker nämns Freud och Lacan med respekt. I en artikel i Svenska Dagbladet om kärlek och skilsmässa citeras Lacan av<strong> Ann Heberlein</strong> ”Att älska är att ge det man inte har till någon som inte vill ha det”.<sup>2</sup> Men sympatiserar Heberlein verkligen med denna cynism, eller vill hon bara signalera att även hon kan Lacan?</p>
<p>Det finns dock en, nej två, mörka sidor av kulturvärldens vurmande för psykoanalys. Den ena är att en pseudovetenskap som Freuds psykoanalys får oförtjänt status. Den andra är att Freud och Lacan även var behandlare, och därmed får oförtjänt status också på det området. Vilket har relevans för prins Harrys strävan att må bättre.</p>
<h2>Är psykoanalytiker klokare än andra?</h2>
<p>Till psykoanalytikers anseende – hos dem som inte känner till hur Freud detroniserats under de senaste femtio åren – bidrar att benämningen <em>psykoanalytiker</em> lätt blir ett signalerande varumärke: jag har en djupare förståelse av människans psyke än andra. Till skillnad då från inriktningar som KBT och evolutionspsykologi. De ses som suspekta och förknippas med fyrkantig människosyn och ”reduktionism”, som det ibland heter.</p>
<p>Sådana invändningar missar att en klinisk teori är just en teori om behandling. Som psykolog kan jag använda KBT-upplägg för att de är patientvänliga och har forskningsstöd. Samtidigt inser jag att människan har en komplexitet som omfattar mycket mer än det som vägleder en behandling. En komplexitet som beror på att evolutionen gett oss egenskaper som ofta drar åt olika håll, såsom att vi både ska samarbeta och konkurrera med andra. Egenskaperna ska dessutom fungera i en historisk kontext med specifika sociala normer. Inte undra på att vi blir komplexa och livet komplicerat.</p>
<p>Men om psykoanalytiker verkligen har större insikter än andra kan ifrågasättas. När Clarence Crafoord – som både är psykoanalytiker och läkare – diskuterar litteratur i <em>Barndomens återkomst</em> hävdar han att <strong>Marcel Prousts</strong> romanverk <em>På spaning efter den tid som flytt</em> grundas på Prousts neurotiska livstema, nämligen ”den omedvetna aggressiviteten och frustrationen i fantasin att återvända till modersskötet” (sidan 69). Proust var ju homosexuell, och det framhålls även att skräcken för moderns könsorgan ”kan bidra till en homosexuell orientering” (sidan 63).</p>
<p>Fascinerande tankegångar, det medges. Men att klistra freudianska postulat på Prousts verk ger knappast någon fördjupad förståelse. Och att en nutida läkare kopierar Freuds idéer om hur homosexualitet kan uppkomma, är inte så fräscht.</p>
<p>Dessutom, här uppstår en paradox. Psykoanalytiker vill gärna framhålla att man ser människans mångtydighet och komplexitet. Men när psykoanalytiker ska analysera litteratur reduceras ofta människan till ett fåtal drivkrafter, såsom oidipala strävanden eller önskningar om att återvända till livmodern.</p>
<p>Den ena mörka sidan är alltså att de som titulerar sig som psykoanalytiker och tillämpar Freuds tankegods tillskrivs en större klokskap än de nog har. Den andra mörka sidan är att när det vurmas för Freud och Lacan bortses det från att det inte rätt och slätt rör sig om två mysfarbröder med suggestiva tankar, de har även tagit sig an att hjälpa människor.</p>
<p>Då kan det vara intressant att göra ett tankeexperiment. Anta att en kulturskribent drabbas av ett diagnostiserbart lidande, såsom paniksyndrom eller depression. Vilken vård skulle föredras: modell Freud, modell Lacan eller moderna forskningsförankrade metoder?</p>
<h2>Freud och Lacan som behandlare</h2>
<p>Hos Freud skulle det vara viktigt att få en kvinnlig patient att tillstå sin penisavund, och få den manlige patienten att erkänna att han hyser rädsla för att fadern skulle kastrera honom. Och oavsett kön skulle frågor ställas om onani i såväl vuxenliv och som barn, för enligt Freud spelar onani ofta en roll för psykiska problem.</p>
<p>Det kanske inte låter så lockande. Och spännande nog, psykoanalytikern<strong> Ulrike May</strong> har i boken <em>Freud at work</em> försökt göra en utvärdering av Freuds terapier under perioden 1910-1920. Av 19 granskade patienter verkar Freud haft framgång med en. I övrigt var resultatet dåligt eller oklart, och det gällde även för de tre patienterna med över tusen sessioner.</p>
<p>Framgångar i terapin hos Freud verkar alltså sällsynta. Samtidigt bör man veta att det finns de som uttryckt uppskattning av behandlingen hos honom.</p>
<blockquote><p>Han drog sig inte för att försöka inleda en sexuell relation utanför sessionerna.</p></blockquote>
<p>Lacan framhåller att patienten i analysen ska hitta sitt begär, vilket nog kan vara bra för en del. Men den som valde honom kunde få nöja sig med ett kort besök.</p>
<p>Det berodde på att Lacan – med sitt dunkla tal och självsäkra framtoning – kom att betraktas som mannen med de högsta insikterna om det mänskliga: att då få träffa honom blev nästan som att få audiens hos gud.<sup>3</sup> Men när Lacan blev mer efterfrågad tackade han inte nej utan drog ner på sessionernas längd – och kunde därmed bli allt rikare – och i slutet av sitt liv var han nere på ett fåtal minuter.</p>
<p>Kanske inte så lockande att betala för. Och om patienten rörde sig om en kvinna som Lacan fann attraktiv, drog han sig inte för att försöka inleda en sexuell relation utanför sessionerna.</p>
<p>Precis som i Freuds fall finns dock anekdotisk evidens för att patienter haft nytta av sessionerna hos Lacan, och i sin bok om Lacan nämner Roudinesco en kvinnlig patient som beskriver honom som ”fantastiskt lyhörd” (sidan 440).</p>
<p>Gentemot det förda resonemanget finns en given invändning: psykoanalytisk terapi har släppt en hel del av Freuds tankegods. Det stämmer och är bra. Ofta handlar det numer om att få patienten att bli mer uppriktig om känslor den inte är helt medveten om, eller uppfattar som skamliga. Men att vara äkta är ett mål i<strong> Carl Rogers</strong> humanistiska terapi, inte hos Freud.</p>
<p>Gällande de diagnoser som jag nämnt – paniksyndrom och depression – finns behandlingsformer som har stöd i systematisk forskning, både i den psykodynamiska inriktningen och inom KBT.</p>
<p>Det går bra att fnysa åt evidensbasering så länge man befinner sig i en kultursidas värld. Men om man själv eller någon anhörig drabbas av något allvarligt, är det nog en behandling med starkt forskningsstöd som efterfrågas, och inte bara en som stöds av anekdotisk evidens.</p>
<p>Givetvis är det inget fel att en kultursida välkomnar skribenter som kallar sig psykoanalytiker, de kan ha intressanta saker att förmedla. Men det är inte heller beundransvärt att lyfta fram dem som ställt sig utanför den forskningsförankrade psykoterapin. En tankegång som kan illustreras av prins Harry.</p>
<h2>Dumhet snarare än dödsdrift?</h2>
<p>Prinsen har i en intervju med den amerikanska pratshowvärden <strong>Oprah Winfrey</strong> berättat att han under flera år haft ångest som lindrats med alkohol, ångest som berott på smärtsamma minnen av förlusten av modern som tolvåring.<sup>4</sup></p>
<p>Prinsen blev en sökare på terapiområdet, men det som hjälpte honom med hans trauma var den forskningsförankrade metoden EMDR (<em>Eye Movement Desensitization and Reprocessing Therapy</em>).<sup>5</sup> Det var bra att han inte valde psykoanalys. För trots att många tror att så är fallet så saknas det vetenskapligt stöd för psykoanalys som behandlingsmetod vid trauma. Forskningen visar att då behövs något annat än psykoanalysens fria pratande.<sup>6</sup></p>
<p>Det kan dock framhållas att individuell skicklighet är viktigt vid psykoterapi. En psykoanalytiker kan därför vara bra för den som vill ha någon att prata med. Men vid många diagnoser är sådan behandling inget att rekommendera, till exempel vid fobier, tvång, generell oro eller traumatiska minnesbilder.</p>
<p>Jag hoppas att prins Harrys öppenhet inte vänds emot honom. Men risken finns att boken leder till ytterligare självdestruktivitet. Inte som ett uttryck för en dödsdrift, utan på grund av ogenomtänkthet. Jag vågar göra en KBT:ig analys: människor väljer ofta kortsiktiga fördelar framför det som är långsiktigt bra.</p>
<p>Prinsen har satsat på en kortsiktig framgång i form av pengar och medkännande uppmärksamhet. Men innehållet är sådant att det riskerar att leda till mer konflikter med släkten, vilket på sikt kan försämra hans psykiska hälsa och öka risken för självdestruktivitet. En risk som Moehringer inte hittar hos Freud, och som han inte behöver ta ansvar för. Men som kan vara något för oss andra att betänka, när det gäller hur vi vill leva våra liv.<a href="#_ednref1" name="_edn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="85294">  <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><strong>Litteratur</strong></p>
<p>Crafoord, C. (1993). <em>Barndomens återkomst: En psykoanalytisk och litterär studie</em>. Natur och Kultur: Stockholm.</p>
<p>May, U. (2018). <em>Freud at work: On the history of psychoanalytic theory and practice, with an analysis of Freud&#8217;s patient record books</em>. New York: Routledge.</p>
<p>Roudinesco, E. (1994). <em>Jacques Lacan: En levnadsteckning, ett tankesystems historia</em>. Stockholm: Symposion.</p>
<p>&nbsp;</p>
<p>1, <a href="https://www.bbc.com/news/world-us-canada-64217330">https://www.bbc.com/news/world-us-canada-64217330</a></p>
<p>2, <a href="https://www.svd.se/a/7dEQ73/ann-heberlein-om-varfor-sa-manga-vill-skilja-sig-efter-semestern">https://www.svd.se/a/7dEQ73/ann-heberlein-om-varfor-sa-manga-vill-skilja-sig-efter-semestern</a></p>
<p>3, Uppgifterna om Lacan kommer från Elisabeth Roudinescos fascinerande biografi om honom.</p>
<p>4, <a href="https://www.youtube.com/watch?v=QGiqBazdPGw&amp;t=31s">https://www.youtube.com/watch?v=QGiqBazdPGw&amp;t=31s</a></p>
<p>5, <a href="https://www.dailymail.co.uk/femail/article-11601757/A-look-Prince-Harrys-longstanding-relation-therapy.html">https://www.dailymail.co.uk/femail/article-11601757/A-look-Prince-Harrys-longstanding-relation-therapy.html</a></p>
<p>6, <a href="https://www.apa.org/ptsd-guideline/treatments">https://www.apa.org/ptsd-guideline/treatments</a></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
</div>
</div>
<div class="author-byline">Billy Larsson är leg psykolog, leg psykoterapeut, fil dr i psykologi och författare. Bland annat<br />
till boken <em>Klimatkatastrofens psykologi och mänsklighetens framtid – Det etiska alternativet</em>.
</div>
</div>
