Snart kan vi skapa människor som är smartare än Einstein

<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-113824"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="113824" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9qci1zbmFydC1rYW4tdmktc2thcGEtbWFubmlza29yLXNtYXJ0YXJlLWFuLWVpbnN0ZWluLTgtMzYtbWFzdHJhZC5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvanItc25hcnQta2FuLXZpLXNrYXBhLW1hbm5pc2tvci1zbWFydGFyZS1hbi1laW5zdGVpbi04LTM2LW1hc3RyYWQubXAz">  <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> | 28 november 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%2Fsnart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein%2F&amp;t=Snart+kan+vi+skapa+m%C3%A4nniskor+som+%C3%A4r+smartare+%C3%A4n+Einstein"    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=Snart+kan+vi+skapa+m%C3%A4nniskor+som+%C3%A4r+smartare+%C3%A4n+Einstein+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsnart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein%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%2Fsnart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Snart kan vi skapa människor som är smartare än Einstein&body=https://kvartal.se/artiklar/snart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/113824/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/113824/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%2Fsnart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein%2F&amp;t=Snart+kan+vi+skapa+m%C3%A4nniskor+som+%C3%A4r+smartare+%C3%A4n+Einstein"    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=Snart+kan+vi+skapa+m%C3%A4nniskor+som+%C3%A4r+smartare+%C3%A4n+Einstein+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsnart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein%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%2Fsnart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Snart kan vi skapa människor som är smartare än Einstein&body=https://kvartal.se/artiklar/snart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/113824/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/113824/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/snart-kan-vi-skapa-manniskor-som-ar-smartare-an-einstein/?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/113824"    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-113824">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "113824"></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 "><strong>Stephen Hsu</strong> är en väldigt smart kille. Vid tolv års ålder började han läsa datavetenskap på collegenivå och sju år senare tog han examen från California Institute of Technology, där han studerade fysik för professorn och nobelpristagaren <strong>Richard Feynman</strong>. Hsu blev så småningom själv professor i såväl teoretisk fysik som beräkningsmatematik vid Michigan State University.</p>
</div>
<div class="rest-of-article ">
<p>Utöver sitt arbete som fysiker driver Stephen Hsu en populär blogg<sup>1</sup> och har publicerat banbrytande forskningsresultat inom genetik.<sup>2 3</sup> År 2017 grundade han Genomic Prediction Inc. (sedermera känt som <em>LifeView</em>) – ett företag som tillhandahåller genetisk screening av mänskliga embryon som används vid så kallad in vitro-befruktning (IVF). Genom att screena för generna bakom folksjukdomar som diabetes och cancer försöker Hsu och hans kollegor erbjuda infertila par friskare och mer livsdugliga barn.</p>
<p>Professor Hsus arbete och ställningstaganden inom genetik har väckt anstöt bland hans kollegor inom akademin, varav vissa ser honom som en förespråkare för rashygien eller eugenik, som det ibland kallas. Sådana anklagelser tvingade rentav Hsu att avgå från en viktig chefspost för några år sedan.<sup>4</sup></p>
<p>Stephen Hsu har dock slagit ifrån sig kritiken, och beskriver genetisk ingenjörskonst som avgörande för mänsklighetens framtid.</p>
<p><strong>EWL: Du är utbildad inom teoretisk fysik. Du har ingen bakgrund inom vare sig biologi eller genetik. Så vad gör dig till en auktoritet inom genetisk forskning?</strong></p>
<p><strong>SH</strong>: För att begripa det behöver man kunna lite om ämnets historia. För cirka tjugo år sedan kartlades det mänskliga genomet. Sedan dess har forskare över hela världen samlat in DNA från miljontals människor i jättelika databaser. Man har också dokumenterat vad dessa personer har för sjukdomar och andra egenskaper. Att analysera all denna information är en uppgift för matematiker och datavetare, snarare än biologer eller genetiker. Mycket få specialister inom genetik kan tillräckligt mycket om maskininlärning eller AI för att kunna hantera dessa enorma datamängder. De flesta av mina medförfattare har examina i fysik, matematik eller datavetenskap. Knappt någon är biolog eller genetiker.</p>
<p><strong>Du var med och grundade ett företag som sysslar med genetisk testning. Vilka tjänster erbjuder ni era kunder?</strong></p>
<p>I nuläget fokuserar vi på genetisk analys av embryon som används vid IVF. För att genomföra IVF krävs bara ett embryo, men de flesta kvinnor producerar flera stycken per IVF-cykel. För att hjälpa kvinnor att välja bland embryon har man traditionellt genomfört en högst ytlig analys av embryonas utseende eller morfologi. Vårt företag erbjuder en analys av varje embryos DNA, där vi letar efter förändringar som ökar risken för olika sjukdomar. Vi samarbetar för närvarande med drygt tvåhundra IVF-kliniker över hela världen.</p>
<figure id="attachment_113919" aria-describedby="caption-attachment-113919" style="width: 1096px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-113919 size-full" src="https://kvartal.se/wp-content/uploads/2023/11/Stephen_Hsu.png" alt="kvartal" width="1096" height="1420" data-wp-pid="113919" srcset="https://kvartal.se/wp-content/uploads/2023/11/Stephen_Hsu.png 1096w, https://kvartal.se/wp-content/uploads/2023/11/Stephen_Hsu-600x777.png 600w, https://kvartal.se/wp-content/uploads/2023/11/Stephen_Hsu-232x300.png 232w, https://kvartal.se/wp-content/uploads/2023/11/Stephen_Hsu-768x995.png 768w" sizes="(max-width: 1096px) 100vw, 1096px" /><figcaption id="caption-attachment-113919" class="wp-caption-text">Stephen Hsu är en amerikansk fysiker.</figcaption></figure>
<p><strong>Att förhindra uppkomsten av sjukdomar på genetisk väg är inte så kontroversiellt. Men var drar man gränsen? Vad händer när era kunder vill veta vilka embryon som innehåller gener för stora öron eller dålig andedräkt?</strong></p>
<p>Ur vetenskaplig synpunkt finns det inget som hindrar oss från att utföra analyser av det slaget. Men vi har valt att inte rapportera sådan information till våra kunder.</p>
<p><strong>Varför inte?</strong></p>
<p>För att det vore oerhört kontroversiellt och skulle i värsta fall komma i vägen för vår kärnverksamhet. Men det är förstås bara en tidsfråga <span style="color: #000000;">innan</span> någon av våra konkurrenter börjar erbjuda DNA-analyser med fokus på utseende, kognitiv förmåga och liknande.</p>
<p><strong>I nuläget sysslar ni bara med DNA-analys och screening av färdiga embryon. Hur stort är steget därifrån till att manipulera den genetiska koden hos mänskliga embryon?</strong></p>
<p>Det är ett ganska stort steg. De flesta mänskliga egenskaper har en polygenetisk grund, vilket innebär att de kontrolleras av hundratals, eller rentav tusentals, olika gener. Den så kallade CRISPR-teknik som används för att manipulera DNA är inte tillräckligt förfinad för den typen av precisionsarbete. Risken att påverka andra delar av genomet av misstag är fortfarande alltför stor.</p>
<p>Därtill så har vi för lite detaljkunskap om hur olika gener fungerar på mikronivå. Idag vet vi ungefär vilka gener som ligger till grund för olika egenskaper. Men varje gen består av hundratals eller tusentals komponenter – så kallade baspar. För att kunna manipulera mänskliga gener på ett säkert sätt måste vi veta exakt vilka individuella baspar som behöver justeras. Och där är vi inte riktigt ännu.</p>
<blockquote><p>Sex är för rekreation, vetenskap är för reproduktion&#8230;</p></blockquote>
<p><strong>En egenskap som många skulle vilja ha är hög intelligens. Finns det någon gräns för hur smarta människor skulle kunna bli om vi manipulerade deras gener?</strong></p>
<p>Vad gäller polygenetiskt grundade egenskaper som intelligens så finns det stort utrymme för förändring. Man behöver bara titta på djuruppfödning som exempel. En ”vanlig” höna i naturen lägger ungefär ett ägg per månad. Men ditt frukostägg lades av en höna som lägger ett ägg om dagen. En hönas förmåga att producera ägg styrs av en stor mängd gener, som har optimerats på vetenskaplig väg. Genom att manipulera gener som kodar för exempelvis intelligens så skulle man kunna flytta medianen för befolkningen tjugo eller trettio standardavvikelser i endera riktningen.</p>
<p><strong>Vi talar alltså om människor med en intelligenskvot omkring 500?</strong></p>
<p>Ja. Inom kort kommer vi att kunna skapa individer som skulle få <strong>Albert Einstein</strong> eller <strong>John von Neumann</strong> att framstå som efterblivna.</p>
<p><strong>Men är det verkligen möjligt att förändra gener som ligger till grund för en viss egenskap utan att påverka en massa andra egenskaper? Är det inte troligt att ett genmanipulerat supergeni skulle få alla möjliga problem, såväl psykiska som fysiska?</strong></p>
<p>Den tekniska termen för det du beskriver är <em>pleitropi</em>. För tio år sedan trodde man att pleitropi var utbrett inom det mänskliga genomet, och att varje individuell gen påverkade en lång rad olika egenskaper. Under sådana omständigheter vore genetisk manipulation oerhört svårt – kanske rentav omöjligt. Men senare års rön har visat på motsatsen.<sup>5</sup> Väldigt många gener styr i själva verket bara en egenskap – exempelvis kroppslängd eller intelligens. För att nå den slutsatsen behöver man dock genomföra mycket komplicerade, matematiska kalkyler av ett slag som sällan genomförs av ”vanliga” biologer eller genetiker. Ur evolutionär synpunkt är en sådan indelning av genomet dock helt logisk, något som biologen <strong>Ronald Fisher</strong> påpekade redan för hundra år sedan.<sup>6</sup></p>
<p><strong>I nuläget är genetisk analys av embryon bara relevant för äldre och infertila par som skaffar barn med hjälp av IVF. Ser du en framtid där även unga och fertila människor väljer att använda IVF?</strong></p>
<p>På jobbet har vi ett internskämt – <em>sex är för rekreation, vetenskap är för reproduktion</em>. Det du beskriver är definitivt ett tänkbart scenario. Teknikerna vi talar om här – IVF och genetisk analys – är trots allt mycket billiga, och skulle lätt kunna göras tillgängliga för fler människor. Man kan också tänka sig en framtid där unga kvinnor rutinmässigt väljer att frysa ner ett par ägg, för att tina upp dem i ett senare skede. På så sätt skulle kvinnorna kunna göra karriär utan att behöva oroa sig för sin sjunkande fertilitet.</p>
<blockquote><p>Enligt min uppfattning har jag mycket lite gemensamt med Hitler.</p></blockquote>
<p><strong>Hur reagerar ”vanliga” biologer och genetiker när du uttalar dig om de här sakerna?</strong></p>
<p>Det beror på vem jag pratar med. Tunga forskare inom kvantitativ genetik, som Shai Carmi<sup>7</sup> eller Abdel Abdellaoui<sup>8</sup>, förstår min forskning och delar mina åsikter om det allra mesta. Andra vill inte kännas vid mitt arbete, eftersom det anses för kontroversiellt. Därtill finns en tendens bland akademiker att ta avstånd från forskare som kommer utifrån, och inte är del av den egna gruppen.</p>
<p><strong>Vissa menar att <em>epigenetik</em> – det vill säga omgivningens påverkan på olika geners funktion – underminerar alla argument om genetisk determinism. Stämmer det?</strong></p>
<p>Epigenetik är ett reellt fenomen, och självklart påverkas våra gener av alla möjliga faktorer som inte går att utläsa i den genetiska koden. Men sådana effekter är ganska små, åtminstone under ett normalt människoliv. Epigenetik kan exempelvis förklara skillnaden i kroppslängd mellan två enäggstvillingar. Men som vi alla vet tenderar enäggstvillingar att vara nästan exakt lika långa.<sup>9 10</sup> Epigenetiken får stort utrymme i populärvetenskapliga medier, men dess betydelse är kraftigt överskattad.</p>
<p><strong>Du har anklagats för att förespråka <em>eugenik</em>. Gör du det?</strong></p>
<p>För att svara på den frågan behöver jag först veta vad du menar med eugenik. Om en mor råder sin dotter att inte skaffa barn med en schizofren man, förespråkar hon då eugenik? Om en kvinna väljer att abortera ett foster med Downs syndrom, praktiserar hon då eugenik? Och är det i så fall omoraliskt? Mina kritiker är inte så noga med att definiera sina termer. De vill bara ha sagt att den där Stephen Hsu minsann är precis som <strong>Adolf Hitler</strong>. Och det håller jag inte med om. Enligt min uppfattning har jag mycket lite gemensamt med Hitler.</p>
<p><strong>Varifrån kommer det politiska motståndet mot den här typen av verksamhet – från högern eller vänstern?</strong></p>
<p>Vissa på högerkanten motsätter sig tekniker som för med sig att ett stort antal embryon kasseras, något de anser vara ett brott mot människans värdighet. Många ideologer inom vänstern klamrar sig fast vid urmodiga dogmer om social konstruktivism, och ogillar allt som har med gener att göra. De oroar sig också över att genetisk manipulation kommer att förvärra klyftorna i samhället.</p>
<p><strong>Är inte det en rimlig farhåga?</strong></p>
<p>Absolut. På kort sikt tror jag att genetisk ingenjörskonst kommer att leda till mer ojämlikhet, eftersom tekniken i första hand kommer att göras tillgänglig för rika människor. Men historien behöver inte sluta där. Ett land som Sverige skulle exempelvis kunna erbjuda alla medborgare genetisk analys eller manipulation inom ramen för den offentliga sjukvården. I så fall skulle ojämlikheten minska.</p>
<blockquote><p>För närvarande ser det ut som om vi tappar ett par IQ-poäng per generation, vilket förstås är mycket oroande.</p></blockquote>
<p><strong>Universitetsanställda forskare tycks känna sig rätt obekväma med genetisk ingenjörskonst. Är det därför rimligt att tro att genombrott inom det här området kommer att drivas av privata företag eller nationella aktörer som Kina?</strong></p>
<p>Det stämmer nog. Mina kollegor på västerländska universitet är mycket försiktiga, och ständigt rädda för att bli cancelled. Privata företag har något större frihet. Men i länder som Indien och Kina är det ideologiska klimatet helt annorlunda, och man har en mer positiv syn på genetisk selektion. Kritiken mot vår verksamhet kommer mest från inskränkta vita människor med en mycket orealistisk bild av sin omvärld. Vänstern i Europa och USA tror sig kunna stänga ner vilken diskussion som helst genom att nämna Adolf Hitler. Men kineser eller indier bryr sig inte ett dugg om honom. Däremot bryr de sig om sina barns hälsa, och kommer inte att låta sig påverkas av en massa hysteriska västerlänningar.</p>
<p><strong>Genetisk ingenjörskonst inger hopp om en ljusare framtid, där alla människor är smartare, friskare och mer produktiva. Men allt kan förstås också sluta illa för mänskligheten. Vad ser du som de största farorna med den här typen av teknologi?</strong></p>
<p>Jag oroar mig främst för två olika scenarier. Ett av dem beskrevs mycket väl i <strong>Mike Judges</strong> film <em>Idiocracy</em> från år 2006. Den handlar om en dystopisk framtid där mänskligheten har blivit väldigt korkad. <em>Idiocracy</em> är en påhittad historia, men den utveckling som skildras i filmen kan mycket väl bli verklighet. Om smarta människor skaffar färre barn än mindre smarta människor så kommer det att sänka befolkningens genomsnittliga intelligens. Genetiska studier har redan påvisat en sjunkande kognitiv förmåga, åtminstone i Västvärlden.<sup>11</sup> För närvarande ser det ut som om vi tappar ett par IQ-poäng per generation, vilket förstås är mycket oroande.</p>
<p>Det andra scenariot är det som vi diskuterade tidigare, där genetisk teknologi endast görs tillgänglig för rika människor. Man kan då föreställa sig ett slags oligarki av genetiskt optimerade individer, som styr över en växande och alltmer desperat underklass. Även detta scenario kan bli verklighet, eller avstyras på politisk väg, om stater väljer att göra de här metoderna tillgängliga för alla sina medborgare. Det är upp till oss själva att bestämma hur historien slutar.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="113824">  <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><a href="https://infoproc.blogspot.com/">https://infoproc.blogspot.com/</a></li>
<li><a href="https://academic.oup.com/genetics/article/210/2/477/5931053">https://academic.oup.com/genetics/article/210/2/477/5931053</a></li>
<li><a href="https://arxiv.org/abs/2101.05870">https://arxiv.org/abs/2101.05870</a></li>
<li><a href="https://firestephenhsu.github.io/">https://firestephenhsu.github.io/</a></li>
<li><a href="https://infoproc.blogspot.com/2020/03/pleiotropy-myths-and-reality.html">https://infoproc.blogspot.com/2020/03/pleiotropy-myths-and-reality.html</a></li>
<li><a href="https://en.wikipedia.org/wiki/Fisher%27s_geometric_model">https://en.wikipedia.org/wiki/Fisher%27s_geometric_model</a></li>
<li><a href="https://www.manifold1.com/episodes/shai-carmi-polygenic-risk-scores-embryo-screening-5">https://www.manifold1.com/episodes/shai-carmi-polygenic-risk-scores-embryo-screening-5</a></li>
<li><a href="https://www.manifold1.com/episodes/abdel-abdellaoui-genetics-research-and-the-connection-to-health-outcomes-and-educational-attainment-24">https://www.manifold1.com/episodes/abdel-abdellaoui-genetics-research-and-the-connection-to-health-outcomes-and-educational-attainment-24</a></li>
<li><a href="https://infoproc.blogspot.com/2020/10/replications-of-height-genomic.html">https://infoproc.blogspot.com/2020/10/replications-of-height-genomic.html</a></li>
<li><a href="https://www.nature.com/articles/s41586-022-05275-y">https://www.nature.com/articles/s41586-022-05275-y</a></li>
<li><a href="https://pubmed.ncbi.nlm.nih.gov/28096410/">https://pubmed.ncbi.nlm.nih.gov/28096410/</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>
