Så hanteras en kvantmobbare

<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-173089"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="173089" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="U8OlIGhhbnRlcmFzIGVuIGt2YW50bW9iYmFyZQ==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9zYS1oYW50ZXJhcy1lbi1rdmFudG1vYmJhcmUubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2EtaGFudGVyYXMtZW4ta3ZhbnRtb2JiYXJlLm1wMw==">  <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/torbjorn-vestberg/">Torbjörn&nbsp;Vestberg</a> | 8 april 2025<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-hanteras-en-kvantmobbare%2F&amp;t=S%C3%A5+hanteras+en+kvantmobbare"    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+hanteras+en+kvantmobbare+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-hanteras-en-kvantmobbare%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-hanteras-en-kvantmobbare%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så hanteras en kvantmobbare&body=https://kvartal.se/artiklar/sa-hanteras-en-kvantmobbare/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/173089/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="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%2Fsa-hanteras-en-kvantmobbare%2F&amp;t=S%C3%A5+hanteras+en+kvantmobbare"    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+hanteras+en+kvantmobbare+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-hanteras-en-kvantmobbare%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-hanteras-en-kvantmobbare%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så hanteras en kvantmobbare&body=https://kvartal.se/artiklar/sa-hanteras-en-kvantmobbare/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/173089/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/sa-hanteras-en-kvantmobbare/?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 5 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/627cee24-9b73-44cd-9b7d-a14ef911afaa"    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-173089">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "173089"></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 ">Kan vi förstå <strong>Donald Trumps</strong> grepp om sina väljare genom kvantteori? Vid en första anblick låter det långsökt. Men begrepp som<em> superposition</em>, <em>emergens</em>, <em>kvantsammanflätning</em>, <em>interferens</em> och <em>vågfunktionskollaps </em>kan hjälpa oss att förstå hur Trump fungerar – och kanske viktigast: hur vi kan hantera honom.</p>
</div>
<div class="rest-of-article ">
<h2>Trump kan vara på flera positioner samtidigt</h2>
<p>Trump är inte bara en politisk ledare. Han är ett politiskt fenomen. För vissa är han en <em>outsider</em> som kämpar mot ett korrupt etablissemang. För andra är han en destruktiv kraft som underminerar demokratiska institutioner. Båda dessa bilder existerar samtidigt, beroende på vem som betraktar honom. Det påminner om kvantteorins <em>superposition</em> – en partikel kan vara både här och där tills den observeras. Trump förändras beroende på hur vi ser på honom.</p>
<p>Men hans makt handlar inte bara om honom själv. Den bygger på samspelet med hans anhängare. Han är mer än en aktör – han har blivit en symbol och del av ett större system. När medier eller motståndare attackerar honom uppfattas det av många följare som ett angrepp även på dem. På så vis skapas en lojalitet som är svår att bryta.</p>
<p>Trumps makt bygger på en process där sociala medier, politisk lojalitet, populism och konspirationsteorier samverkar till ett självförstärkande system – en form av <em>emergens </em>[se ordförklaring nedan]. Likt <em>kvantsammanflätning</em> kopplas olika skilda frågor som abort, jobb i rostbältet och invandring samman, oavsett det ideologiska avståndet mellan dem. Ju mer uppmärksamhet Trump får, desto starkare blir rörelsen. Det uppstår <em>konstruktiv interferens;</em> varje kontrovers får hans väljare, med till synes olika åsikter, att sluta sig tätare kring honom. Hans styrka ligger i att han får definiera debatten. Frågan är: Hur bryter vi detta grepp?</p>
<h2>Låt inte önsketänkande forma politiken</h2>
<p>Historien visar att vissa ledare styr genom hur de uppfattas snarare än vad de faktiskt gör.</p>
<p><strong>Neville Chamberlain</strong>, Storbritanniens premiärminister 1937–1940, är mest känd för sitt försök att blidka <strong>Hitler</strong> genom eftergiftspolitik. Efter mötet i München 1938 deklarerade han: <em>Peace for our time</em>. Chamberlain ville inte se Hitlers aggressiva ambitioner. Han reducerade en komplex verklighet till en bild som passade hans förhoppningar. Konsekvensen blev en <em>vågfunktionskollaps</em>.</p>
<p>Samma fenomen ser vi idag. Vissa ser Trump som en stark ledare men ignorerar riskerna med hans auktoritära tendenser. I båda fall reduceras verkligheten till en förenklad bild som bekräftar egna önskningar.</p>
<blockquote><p>Erfarenheten av övertro på sin egen förträfflighet gjorde Churchill vaksam.</p></blockquote>
<p>Till skillnad från Chamberlain förstod <strong>Winston Churchill</strong> Hitler. Kanske för att han konfronterat sina egna brister. Efter fiaskot vid Gallipoli under första världskriget, när minst 56 000 soldater dödades, drabbades Churchill av en djup depression – sin <span style="font-weight: 400;">”</span>svarta hund<span style="font-weight: 400;">”</span>. Självrannsakan gav honom en klarare blick. När Hitler kom till makten förblindades inte Churchill. Han skrev: <span style="font-weight: 400;">”</span><em>He (Hitler) became possessed of a boundless ambition and a firm belief in his own star.<span style="font-weight: 400;">”</span></em><sup>1</sup> Erfarenheten av övertro på sin egen förträfflighet gjorde Churchill vaksam. Lärdomen är tydlig: en ledare utan självrannsakan är farlig. Trump, liksom Hitler, visar inga tecken på självkritik – och förändras inte genom argument.</p>
<p>Churchill insåg också att Hitlers makt var känslomässigt sammanflätad med folket. Efter utrensningen som blivit känd som De långa knivarnas natt år 1934 skrev Churchill: <span style="font-weight: 400;">”</span><em>The great German People [&#8230;] have not only not resented this horrible blood-bath</em>, <em>but have endorsed it and acclaimed its author with the honours not only of a sovereign but almost of a God.<span style="font-weight: 400;">”</span></em><sup>1</sup> Hitlers makt kunde inte besegras med diplomati. Det handlade inte bara om politik – utan om känslor och identitet.</p>
<h2>En strategi för att hantera Trump</h2>
<p>Trump är en <em>kvantmobbare</em> – hans makt finns i flera tillstånd samtidigt och förstärks av uppmärksamhet. Traditionella strategier för att hantera en mobbare fungerar inte. Men genom att kombinera dessa punkter med kvantteori kan vi få vägledning.</p>
<p>För att minska hans inflytande måste vi förändra vår reaktion.</p>
<ul>
<li>Sluta belöna honom. Ju mer vi pratar om Trump, desto starkare blir han. Destruktiv interferens kräver att vi skapar nya berättelser som förminskar Trumps dominans. Exempel: Visioner om en Atlantunion mellan EU och Kanada.</li>
<li>Undvik direkt konfrontation. Den stärker hans outsiderskap och ökar väljarnas lojalitet.</li>
<li>Det funkar inte att anmäla till högre instans. Att försöka få Trump ställd inför högsta juridiska instans och fälld för brott har inte hjälpt. Trump betraktas redan som den högsta auktoriteten av sina följare, och därför fungerar inte den vanliga metoden att hantera mobbare. Riksrätten blev för anhängarna bara ytterligare bevis på elitens förföljelse av Trump.</li>
</ul>
<p>Visa ingen rädsla. När Tysklands dåvarande förbundskansler <strong>Angela Merkel</strong> bemötte Trumps retorik sakligt och lugnt tappade han sin kraft. Inte ens när han kysste henne på kinden och sa: ”<em>I love this woman</em>”,<em><sup>2</sup></em> förlorade hon balansen. Merkel fokuserade på stabilitet och långsiktighet – och lät Trump montera ner sin konflikt själv. Det är en strategi att lära av.</p>
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-tkxwfJjGPN"></p>
<p><strong>Ordförklaringar</strong></p>
<ul>
<li><em>Kvantteori</em> – En fysikalisk teori som beskriver materiens och energins beteende på subatomnivå.</li>
<li><em>Superposition</em> – Innebär att en partikel kan befinna sig i flera tillstånd samtidigt tills den observeras.</li>
<li><em>Emergens</em> – Fenomen där en helhet uppvisar egenskaper som inte kan förutsägas utifrån dess enskilda delar.</li>
<li><em>Kvantsammanflätning</em> – Ett tillstånd där två partiklar förblir sammankopplade, oavsett avstånd, så att en förändring hos den ena påverkar den andra.</li>
<li><em>Konstruktiv interferens</em> – När vågor samverkar och förstärker varandra, vilket leder till ökad effekt.</li>
<li><em>Destruktiv interferens</em> – När vågor motverkar varandra och försvagas eller elimineras helt.</li>
<li><em>Vågfunktionskollaps </em>– När en partikel, som ursprungligen beskriver flera möjliga tillstånd, samtidigt plötsligt reduceras till ett enda specifikt tillstånd genom att partikeln observeras eller mäts.</li>
</ul>
<p></div>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="173089">  <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><em>The truth about Hitler </em>(The Standard Magazine 1935)</li>
<li><em>How Trump made war on Angela Merkel and Europe </em>(The New Yorker<em> </em>2018)</li>
</ol>
<p>&nbsp;</p>
</div>
</div>
<div class="author-byline">Torbjörn Vestberg är medicine doktor i kognitiv neurovetenskap och psykolog.
</div>
</div>
