I korthet
För några år sedan lyssnade jag på ett föredrag vid ett ansett amerikanskt universitet. Talaren var psykoterapeut och expert på posttraumatiskt stressyndrom, vanligen förkortat PTSD. Hennes budskap var att den rådande definitionen av psykologiskt trauma var på tok för snäv och måste utvidgas.
<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-85867"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="85867" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3Rfc2FfYmxldl90cmF1bWFfcG9saXRpay5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2EtYmxldi10cmF1bWEtcG9saXRpay5tcDM=">  <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/erik-w-larsson/">Erik W.&nbsp;Larsson</a> | 30 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%2Fsa-blev-trauma-politik%2F&amp;t=S%C3%A5+blev+trauma+politik"    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=S%C3%A5+blev+trauma+politik+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-blev-trauma-politik%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%2Fsa-blev-trauma-politik%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så blev trauma politik&body=https://kvartal.se/artiklar/sa-blev-trauma-politik/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/85867/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/85867/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="author-section author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </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%2Fsa-blev-trauma-politik%2F&amp;t=S%C3%A5+blev+trauma+politik"    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=S%C3%A5+blev+trauma+politik+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-blev-trauma-politik%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%2Fsa-blev-trauma-politik%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så blev trauma politik&body=https://kvartal.se/artiklar/sa-blev-trauma-politik/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/85867/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/85867/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/sa-blev-trauma-politik/?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 13 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/85867"    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-85867">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "85867"></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 ">För några år sedan lyssnade jag på ett föredrag vid ett ansett amerikanskt universitet. Talaren var psykoterapeut och expert på <em>posttraumatiskt stressyndrom</em>, vanligen förkortat PTSD. Hennes budskap var att den rådande definitionen av psykologiskt trauma var på tok för snäv och måste utvidgas.</p>
</div>
<div class="rest-of-article ">
<p>Så var det dags igen, tänkte jag. När diagnosen PTSD först dök upp i den amerikanska psykiatrins manual DSM (<em>Diagnostic and statistical manual of mental disorders</em>) år 1980 så tillämpades den nästan bara på krigsveteraner. Begreppet <em>trauma</em> var i praktiken liktydigt med erfarenhet av strid. Men under åren som följde anammades diagnosen PTSD av feminister, som påpekade att psykisk sjukdom bland kvinnor ofta har sin grund i övergrepp under uppväxten.</p>
<p>Efter en del debatt utvidgade DSM-kommittén på 1990-talet sin definition av trauma – som snart kom att omfatta allt från sexuella trakasserier på arbetsplatsen till en partners otrohet. Att höra talas om hemskheter som hänt någon annan kunde ibland räcka för en PTSD-diagnos. Ändringarna i DSM gav upphov till en veritabel &#8221;traumaindustri&#8221; av specialiserade terapeuter, kurser och självhjälpsböcker, mestadels riktade till kvinnor.<sup>1</sup></p>
<p>Men vid 2020-talets början var det dags för ännu en omdefiniering av trauma, ansåg vår föreläsare. Nu kunde man inte längre bortse från det förtryck etniska och sexuella minoriteter dagligen får utstå i den moderna västvärlden. Begreppet borde, menade hon, exempelvis innefatta så kallade <em>mikroaggressioner</em> – en form av subtilt kränkande beteenden som ofta är oavsiktliga, och till och med kan inkludera komplimanger.</p>
<p>Via massmedia kunde politiska händelser också orsaka trauma och ge upphov till PTSD. Ett praktexempel var förstås <strong>Donald Trumps</strong> seger över <strong>Hillary Clinton</strong> i det amerikanska presidentvalet 2016 – en händelse som psykoterapeuten sakligt beskrev som ett “nationellt trauma”.</p>
<h2>Inflation och politisering</h2>
<p>Föga förvånande har diagnostiken av posttraumatiskt stressyndrom i USA ständigt ökat sedan början av 1980-talet. För detta finns det flera skäl. Ett uppenbart sådant är att diagnosen PTSD med tiden har kommit att inbegripa allt fler symtom, upplevelser och beteenden – ett fenomen som psykologen <strong>Nick Haslam</strong> kallar för <em>concept creep</em>.<sup>2</sup></p>
<p>En PTSD-diagnos kan också föra med sig ekonomiska fördelar för någon som till exempel har deltagit i krig eller vill stämma sin arbetsgivare för trakasserier. För många personer med psykiska problem är PTSD dessutom en mer attraktiv diagnos än exempelvis ångestsyndrom eller ett personlighetssyndrom. Dessa senare diagnoser antyder förekomsten av något slags medfödd defekt, medan PTSD lägger hela skulden på omgivningen. Vissa patienter som i ungdomen erhåller diagnoser som <em>borderline personlighetssyndrom</em> avkräver senare i livet sina psykologer ett byte av diagnos – till PTSD.</p>
<blockquote><p>I brist på objektiva mätmetoder kan ideologer inom akademin häva ur sig nästan vad som helst om ämnet trauma, utan rädsla för att bli vederlagda.</p></blockquote>
<p>Utöver denna diagnostiska inflation har traumabegreppet genomgått samma politisering som resten av det psykologiska fältet. I en artikel i tidskriften <em>Quillette</em> från 2021 beskrev psykologen <strong>Christopher J. Ferguson</strong> hur det amerikanska psykologförbundet APA på senare år har blivit ett språkrör för identitetspolitik och <em>woke</em> ideologi.<sup>3</sup> Min egen yrkeserfarenhet säger mig att traumapsykologer är mest <em>woke</em> av alla, vilket kanske inte är så konstigt. En person som påstår sig ha en intelligenskvot på 150 går ju lätt att motbevisa, men en person som säger sig ha blivit traumatiserad av en sexistisk kommentar eller en tweet från Donald Trump är desto svårare att säga emot.</p>
<p>I brist på objektiva mätmetoder kan ideologer inom akademin häva ur sig nästan vad som helst om ämnet trauma, utan rädsla för att bli vederlagda.</p>
<h2>Trauma och Trump</h2>
<p>Donald Trumps valseger gav USA:s traumaindustri ett lyft. I media vittnade bekymrade psykologer om en ny och förödande form av PTSD, som de kallade för <em>Post-Trump Stress Disorder</em>.<sup>4</sup> Podcaster, tidningsartiklar och böcker på temat trauma översvämmade marknaden. Mest uppmärksammad blev nog boken<em> The reckoning. Our nation&#8217;s trauma and finding a way to heal (</em>2021). Författare var psykologen <strong>Mary L. Trump</strong>, brorsdotter till presidenten. I <em>The reckoning</em> diagnostiserar doktor Trump hela det amerikanska folket med PTSD – ett tillstånd hon härleder till nationens historiska övergrepp mot indianer, svarta och hbtq-personer.</p>
<p>Dessa obearbetade trauman bidrog till Donald Trumps valseger – ytterligare ett trauma för befolkningen enligt Mary L. Trump, vars vädjan om en landsomfattande gruppterapi togs på stort allvar i amerikanska mainstream-medier.<sup>5</sup></p>
<p>Därmed inte sagt att allt prat om trauma bara är trams. Att obehagliga händelser – särskilt i ungdomen – kan leda till psykisk ohälsa i vuxen ålder är väl belagt av forskningen. Men vi vet också att trauma är något oerhört individuellt. Samma typ av trauma kan få helt olika följder beroende på den drabbades ålder, kön och andra omständigheter. Kvinnor och neurotiska personer löper exempelvis en ökad risk att drabbas av PTSD, jämfört med folk i genomsnitt.<sup>6 7</sup></p>
<p>Det är också svårt att avgöra vad specifika trauman gör för skada, eftersom terapeuter sällan träffar sina klienter både före och efter. Att dra slutsatser om hur hela nationer reagerar psykiskt på specifika händelser är därför orimligt. Ändå spelar tvärsäkra psykoterapeutiska resonemang en stor och växande roll i USA:s offentliga debatt. Det är inte bara terapin som blivit politisk – politiken håller också på att bli terapeutisk.</p>
<h2>Kavanaugh-förhören</h2>
<p>Traumaindustrins inflytande över den politiska processen blev först riktigt kännbart under senatsförhören med <strong>Brett Kavanaugh</strong> – en konservativ domare nominerad till Högsta domstolen av Donald Trump år 2018. Nomineringen fick stor uppmärksamhet eftersom den förväntades ge det republikanska partiet avgörande inflytande i rättssystemets högsta instans. Att blockera Kavanaughs tillträde blev därför en viktig prioritet för Demokraterna och deras allierade i media.</p>
<p>En nyckelperson i Demokraternas kampanj mot Brett Kavanaugh blev <strong>Christine Blasey Ford</strong>, en traumafokuserad psykologiprofessor från Kalifornien. I ett brev till den demokratiska senatorn <strong>Diane Feinstein</strong> skrev Ford att hon i sin ungdom hade blivit antastad av Kavanaugh. Han skulle, i samband med en fest, ha knuffat ner henne på en säng och försökt slita av henne kläderna. Enligt Ford ägde övergreppet rum någon gång under 1982, när hon var 15 år och Kavanaugh 17 år gammal. Händelsen hade märkt henne för livet och gett upphov till svåra, posttraumatiska symtom. Senator Feinstein insåg naturligtvis att allt detta var politiskt sprängstoff, och Christine Blasey Ford flögs till Washington D.C. för att vittna inför senatens justitieutskott.</p>
<p>Senatsförhör av federala domare fokuserar vanligen på kandidatens tolkning av USA:s författning. Men denna gång handlade allt om trauma. Christine Blasey Ford medgav att hon inte mindes var eller när övergreppet hade ägt rum. Det fanns heller inga utomstående vittnen, bara Fords egen försäkran att Brett Kavanaughs hånfulla skratt för evigt hade “etsat sig fast i hennes hippocampus” – en del av hjärnan som hanterar traumatiska minnen. Christine Blasey Fords vittnesmål var djupt rörande, och demokratiska politiker hyllade hennes mod. I tidskrifter som <em>Time Magazine</em> förklarade psykologer att Fords oförmåga att minnas detaljer i själva verket bekräftade att hon varit med om något hemskt, och talade sanning. Juridiska experter lyste med sin frånvaro i media, och Brett Kavanaughs kompetens som domare hamnade i skymundan.<sup>8</sup></p>
<blockquote><p>Man kan också fråga sig varför psykoterapeutisk jargong nästan bara hörs bland demokrater.</p></blockquote>
<p>I slutändan godkändes Brett Kavanaugh – med nöd och näppe – av senaten, och han sitter nu i USA:s högsta domstol. Men det mediala drevet mot honom tydde på ett paradigmskifte i amerikansk debatt. Som <em>New York Times</em> och nättidskriften <em>Vox</em> så allvarsamt förklarade var Christine Blasey Ford långt ifrån ensam om att ha blivit traumatiserad av Kavanaugh.<sup>9 10</sup></p>
<p>Tusentals kvinnor som hörde talas om domarens påstådda brott via tv, Twitter eller Facebook påmindes om sina egna trauman och fick nya PTSD-symtom. De blev <em>retraumatiserade</em>, som det heter på terapeutspråk, och talade ut i sociala medier eller hos någon av mina amerikanska kollegor. Inom kort var Brett Kavanaugh en av USA:s mest hatade personer – i alla fall bland Demokraternas kvinnliga väljare.</p>
<h2>Traumatiserade demokrater</h2>
<p>Vad ligger bakom traumaindustrins växande inflytande inom amerikansk debatt? En tänkbar förklaring skulle kunna vara att fokus har flyttats mot emotionella frågor i takt med att kvinnor tar allt större plats i offentligheten. En amerikansk undersökning från år 2008 visade att män var långt mer intresserade av nyheter om landets högsta domstol än kvinnor.<sup>11</sup> Men vid tidpunkten för undersökningen handlade sådana nyheter mest om torra teknikaliteter, såsom regelverket kring finansiering av politiska kampanjer på federal nivå. Brett Kavanaughs nominering och senatsförhör 2018 engagerade å andra sidan mängder av kvinnliga mediekonsumenter. Om folket önskar mer känslomässig dramatik så kommer politiker och tv-kanaler att ge dem vad de vill ha.</p>
<p>Man kan också fråga sig varför psykoterapeutisk jargong nästan bara hörs bland demokrater. Sociologen <strong>Zach Goldberg</strong> noterade ett intressant mönster när han läste en undersökning från tankesmedjan Pew Research Center från 2020. I undersökningen medgav 38 procent av vita amerikaner som kallade sig &#8221;väldigt liberala&#8221; att de hade en psykiatrisk diagnos, jämfört med bara 15 procent av vita amerikaner som kallade sig &#8221;väldigt konservativa&#8221;. I åldersgruppen 18–29 år var skillnaden mellan grupperna ännu mer slående – 46 procent jämfört med 20 procent.</p>
<p>Överlag var siffrorna betydligt högre bland kvinnor än bland män.<sup>12</sup> För de av oss som arbetat kliniskt med amerikanska collegeungdomar är denna statistik inte särskilt förvånande. Men vad betyder den egentligen? Den betyder <em>inte</em> att amerikaner med vänsterliberala åsikter är “galnare” eller mer verklighetsfrånvända än sina landsmän med högeråsikter. Endast en liten bråkdel patienter lider av psykos eller vanföreställningar. De allra flesta plågas av depression, ångest eller traumarelaterade tillstånd. Diagnoser ställs för det mesta på patientens begäran, och mörkertalen är stora.</p>
<p>Statistiken visar helt enkelt att unga, vita kvinnor med vänsterliberala sympatier är särskilt benägna att söka vård för psykiska besvär. Detta skulle i sin tur kunna förklara varför psykoterapeutisk terminologi på senare år har blivit så vanlig bland demokratiska politiker, särskilt på sociala medier. Politikerna försöker helt enkelt tala samma språk som sina kärnväljare.</p>
<blockquote><p>Den amerikanska vänsterns offermentalitet är inte oproblematisk.</p></blockquote>
<p>Ett ökat fokus på känslor och trauman inom politiken behöver inte nödvändigtvis ses som något negativt. Det behövdes en reaktion mot den råa och toxiskt maskulina ledarstil som kännetecknade det republikanska partiet under Donald Trumps ledning. Trump häcklade sina motståndare och kallade dem fula, feta eller korkade – i synnerhet om de råkade vara kvinnor. Han spelade konstant tuff och tycktes helt sakna empati. Under fyra år upplevde många amerikaner att deras land styrdes av en sadistisk mobbare. Att det demokratiska partiet och deras ledare då ville stötta traumatiserade offer är alltså förståeligt – och på många sätt lovvärt.</p>
<p>Men den amerikanska vänsterns offermentalitet är inte oproblematisk. För varje offer finns det en förövare, som måste straffas hårt. Vi som arbetat med traumatiserade personer vet att de ofta betraktar världen i svart eller vitt, och människor omkring sig som alltigenom goda eller alltigenom onda. En sådan polariserad syn på omgivningen ställer ofta till problem i nära relationer för traumatiserade individer. Men på samhällsnivå kan denna mentalitet få mer långtgående följder och rentav hota rättssäkerheten.</p>
<h2>Ett nationellt trauma</h2>
<p>&#8221;Jag hörde bara folk som ropade VAR ÄR HON? VAR ÄR HON? Då, i det ögonblicket trodde jag att allt var över. Jag trodde att jag skulle dö.&#8221;</p>
<p>Så beskrev den demokratiska kongressledamoten <strong>Alexandra Ocasio-Cortez</strong> (mer känd som AOC) en vecka senare sina känslor under det upplopp som hade ägt rum vid Kapitolium i Washington den 6 januari 2021.<sup>13</sup> AOC fick en del mothugg när det kom fram att hon inte hade befunnit sig i byggnaden vid tidpunkten för själva upploppet. Men kongressledamoten stod på sig, och menade att händelsen hade påmint henne om ett sexuellt övergrepp hon utsatts för några år tidigare. AOC hade, med andra ord, blivit <em>retraumatiserad</em> av nyhetsrapporteringen den 6 januari.</p>
<p>Politiker brukade inte prata på det sättet. Men AOC:s reaktion var ganska typisk för hennes parti. I samband med upploppets årsdag poängterade såväl president <strong>Joe Biden</strong> som representanthusets talman <strong>Nancy Pelosi</strong> hur <em>traumatiskt</em> det hade varit.<sup>14 15</sup> Vicepresidenten <strong>Kamala Harris</strong> gick ett steg längre, och jämförde händelsen med terrordådet mot World Trade Center i september 2001 och flyganfallet mot Pearl Harbor i december 1941.<sup>16</sup></p>
<p>Jämförelsen kan tyckas absurd. Vid attacken mot Pearl Harbor dödades omkring 2400 amerikanska soldater, och en stor del av USA:s Stillahavsflotta slogs ut. Under upploppet vid Kapitolium dödades bara en person – en obeväpnad, kvinnlig demonstrant som sköts i halsen av en polis. Skadegörelsen på själva byggnaden var ringa. Men ur emotionell synpunkt hade Kamala Harris en poäng. Attacken mot Pearl Harbor i Hawaii var gräslig, men den skedde ute till havs och sändes inte på TV. För dem som befann sig på ön var attacken nog så traumatisk, men inte för så många andra.</p>
<p>Upploppet på Kapitolium visades tvärtom på flera tv-kanaler, och därtill på Youtube och Instagram. Ett nationellt <em>trauma</em> hade fötts.</p>
<figure id="attachment_85915" aria-describedby="caption-attachment-85915" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-85915 size-full" src="https://kvartal.se/wp-content/uploads/2023/01/sdl3b1bqyJPzD0-nl.jpg" alt="kvartal" width="1024" height="735" data-wp-pid="85915" srcset="https://kvartal.se/wp-content/uploads/2023/01/sdl3b1bqyJPzD0-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/01/sdl3b1bqyJPzD0-nl-600x431.jpg 600w, https://kvartal.se/wp-content/uploads/2023/01/sdl3b1bqyJPzD0-nl-300x215.jpg 300w, https://kvartal.se/wp-content/uploads/2023/01/sdl3b1bqyJPzD0-nl-768x551.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-85915" class="wp-caption-text">Pearl Harbor på Hawaii bombas av japanskt flyg utan krigsförklaring på morgonen den 7 december 1941. Foto: TopFoto /TT</figcaption></figure>
<p>Vicepresidentens kommentar illustrerar problemet med trauma som politisk kategori. Vilken obehaglig händelse som helst kan upphöjas till ett nationellt trauma om den visas tillräckligt många gånger på tv. Och nationella trauman kan i sin tur åberopas för att berättiga nästan vad som helst – särskilt i ett land vars rättssystem helt genomsyras av partipolitik. Flera år efter upploppet på Kapitolium sitter hundratals demonstranter ännu fängslade utan rättegång – somliga i isoleringscell. Rent juridiskt kan detta verka en smula extremt. Men ur känslomässig synpunkt hör upprorsmakarna hemma på flottbasen Guantanamo Bay med varsin säck över huvudet. De hade ju faktiskt traumatiserat en hel nation.</p>
<h2>En farlig trend</h2>
<p>Detta sentida bruk av psykoterpeutisk jargong bland amerikanska politiker är en smula oväntat. Psykiatrins status som vetenskap har alltid varit låg, och den sjönk ytterligare i samband med den kontrovers som för några år sedan präglade utgåvan av diagnosmanualen DSM-5. Trots detta har psykiatrins politiska inflytande ökat dramatiskt på sistone, åtminstone i USA. Psykiatrer och psykologer konsulteras numera ständigt i media, för att uttolka politikers känsloliv eller ställa diagnos på olika befolkningsgrupper. Detta är förstås mycket skadligt för såväl politiken som psykiatrin.</p>
<p>Historien borde ha lärt oss att sammanblandningen av dessa båda sfärer sällan slutar lyckligt.</p>
<p>Prat om offerskap och psykologiska trauman låter vetenskapligt och spelar effektivt på våra sympatier. Men vem blir offer respektive förövare? <strong>George Floyd</strong>, som dödades av polisen i Minneapolis, fick bli ett offer. Men inte demonstranten <strong>Ashli Babbit</strong>, som dödades av polisen under upploppet vid Kapitolium. Demokraten Christine Blasey Ford fick också bli ett offer. Men inte republikanen Brett Kavanaugh, fastän han hängdes ut som sexförbrytare inför en hel nation. Inte ens när en beväpnad man dök upp vid hans hem för att mörda honom visade vänsterliberaler i media någon sympati för domare Kavanaugh. För dem är han för alltid en förövare, och när hans bild dyker upp i tv-rutan hörs inga stråkar i bakgrunden.</p>
<p>Den burduse Donald Trump uppmuntrade sina partikamrater att bete sig som vissa män gör i ett omklädningsrum. Under Joe Biden uppträder demokrater som om de satt i en terapisoffa. Man kan bara hoppas att dessa båda trender blir kortvariga och att de inte smittar av sig på politiker i Sverige och Europa.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="85867">  <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>
<ol>
<li>Horwitz, A. V. (2021). DSM: a history of psychiatry&#8217;s bible, s. 119. JHU Press.</li>
<li>Tully, J., Bhugra, D., Lewis, S. J., Drennan, G., &amp; Markham, S. (2021). Is PTSD overdiagnosed?. bmj, 373.</li>
<li><a href="https://quillette.com/2021/12/31/my-apa-resignation/">https://quillette.com/2021/12/31/my-apa-resignation/</a></li>
<li><a href="https://www.psychologytoday.com/us/blog/psych-unseen/201611/understanding-post-trump-stress-disorder">https://www.psychologytoday.com/us/blog/psych-unseen/201611/understanding-post-trump-stress-disorder</a></li>
<li><a href="https://www.usatoday.com/story/entertainment/books/2021/08/16/mary-trumps-reckoning-new-book-addresses-traumatized-nation/8103349002/">https://www.usatoday.com/story/entertainment/books/2021/08/16/mary-trumps-reckoning-new-book-addresses-traumatized-nation/8103349002/</a></li>
<li>Olff, M. (2017). Sex and gender differences in post-traumatic stress disorder: an update. European journal of psychotraumatology, 8(sup4), 1351204.</li>
<li>Ogle, C. M., Siegler, I. C., Beckham, J. C., &amp; Rubin, D. C. (2017). Neuroticism increases PTSD symptom severity by amplifying the emotionality, rehearsal, and centrality of trauma memories. Journal of Personality, 85(5), 702-715.</li>
<li><a href="https://time.com/5408567/christine-blasey-ford-science-of-memory/">https://time.com/5408567/christine-blasey-ford-science-of-memory/</a></li>
<li><a href="https://www.nytimes.com/2018/09/26/us/metoo-survivors-kavanaugh-cosby.html">https://www.nytimes.com/2018/09/26/us/metoo-survivors-kavanaugh-cosby.html</a></li>
<li><a href="https://www.vox.com/policy-and-politics/2018/10/2/17928294/kavanaugh-sexual-assault-trauma">https://www.vox.com/policy-and-politics/2018/10/2/17928294/kavanaugh-sexual-assault-trauma</a></li>
<li><a href="https://www.pewresearch.org/2008/02/06/where-men-and-women-differ-in-following-the-news/">https://www.pewresearch.org/2008/02/06/where-men-and-women-differ-in-following-the-news/</a></li>
<li><a href="https://twitter.com/zachg932/status/1248823584111439872">https://twitter.com/zachg932/status/1248823584111439872</a></li>
<li><a href="https://www.facebook.com/NowThisNews/videos/aoc-opens-up-about-the-trauma-of-the-jan-6-capitol-attack/460495418651757/">https://www.facebook.com/NowThisNews/videos/aoc-opens-up-about-the-trauma-of-the-jan-6-capitol-attack/460495418651757/</a></li>
<li><a href="https://www.whitehouse.gov/briefing-room/speeches-remarks/2022/01/06/remarks-by-president-biden-to-mark-one-year-since-the-january-6th-deadly-assault-on-the-u-s-capitol/">https://www.whitehouse.gov/briefing-room/speeches-remarks/2022/01/06/remarks-by-president-biden-to-mark-one-year-since-the-january-6th-deadly-assault-on-the-u-s-capitol/</a></li>
<li><a href="https://www.speaker.gov/newsroom/1622-1">https://www.speaker.gov/newsroom/1622-1</a></li>
<li><a href="https://www.usatoday.com/story/news/politics/2022/01/06/harris-jan-6-like-pearl-harbor-9-11/9116617002/">https://www.usatoday.com/story/news/politics/2022/01/06/harris-jan-6-like-pearl-harbor-9-11/9116617002/</a></li>
</ol>
</div>
</div>
<div class="author-byline">Erik W. Larsson är legitimerad läkare och specialist inom psykiatri, samt ST-läkare inom allmänmedicin.
</div>
</div>
