I korthet
Ponera att du och din partner ska skaffa barn. Även om visionen, glädjen, nervositeten och spänningen är både ömsesidig och likvärdig i magnitud så står ni inför en enorm orättvisa – en evolutionär konflikt som förekommer hos alla organismer med sexuell reproduktion.
För en hane av arten Homo sapiens är den minsta möjliga ansträngningen för att producera avkomma en ejakulation. För en hona av samma art är den minsta möjliga ansträngningen en nio månader lång graviditet, en förlossningssmärta som saknar motstycke, och utan sjukvård är risken att dö på kuppen tämligen hög. Siffran har varierat i tid och rum, men risken för mödradödlighet har hos vissa jägar- och samlarsamhällen skattats till drygt 3 procent.
<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-99318"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="99318" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="QWxsdCBkdSB2ZWxhdCB2ZXRhIG9tIHNleCwgbWVuIGludGUgdsOlZ2F0IGZyw6VnYSBvbQ==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9hbGx0X2R1X3ZlbGF0X3ZldGFfb21fc2V4X21lbl9pbnRlX3ZhZ2F0X2ZyYWdhX29tLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvYWxsdC1kdS12ZWxhdC12ZXRhLW9tLXNleC1tZW4taW50ZS12YWdhdC1mcmFnYS1vbS5tcDM=">  <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/jerker-vinterstare/">Jerker&nbsp;Vinterstare</a> | 18 juli 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%2Fallt-du-velat-veta-om-sex-men-inte-vagat-fraga-om%2F&amp;t=Allt+du+velat+veta+om+sex%2C+men+inte+v%C3%A5gat+fr%C3%A5ga+om"    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=Allt+du+velat+veta+om+sex%2C+men+inte+v%C3%A5gat+fr%C3%A5ga+om+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fallt-du-velat-veta-om-sex-men-inte-vagat-fraga-om%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%2Fallt-du-velat-veta-om-sex-men-inte-vagat-fraga-om%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Allt du velat veta om sex, men inte vågat fråga om&body=https://kvartal.se/artiklar/allt-du-velat-veta-om-sex-men-inte-vagat-fraga-om/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/99318/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%2Fallt-du-velat-veta-om-sex-men-inte-vagat-fraga-om%2F&amp;t=Allt+du+velat+veta+om+sex%2C+men+inte+v%C3%A5gat+fr%C3%A5ga+om"    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=Allt+du+velat+veta+om+sex%2C+men+inte+v%C3%A5gat+fr%C3%A5ga+om+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fallt-du-velat-veta-om-sex-men-inte-vagat-fraga-om%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%2Fallt-du-velat-veta-om-sex-men-inte-vagat-fraga-om%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Allt du velat veta om sex, men inte vågat fråga om&body=https://kvartal.se/artiklar/allt-du-velat-veta-om-sex-men-inte-vagat-fraga-om/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/99318/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/allt-du-velat-veta-om-sex-men-inte-vagat-fraga-om/?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 37 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/99318"    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-99318">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "99318"></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 ">Ponera att du och din partner ska skaffa barn. Även om visionen, glädjen, nervositeten och spänningen är både ömsesidig och likvärdig i magnitud så står ni inför en enorm orättvisa – en evolutionär konflikt som förekommer hos alla organismer med sexuell reproduktion.</p>
<p>För en hane av arten Homo sapiens är den minsta möjliga ansträngningen för att producera avkomma en ejakulation. För en hona av samma art är den minsta möjliga ansträngningen en nio månader lång graviditet, en förlossningssmärta som saknar motstycke, och utan sjukvård är risken att dö på kuppen tämligen hög. Siffran har varierat i tid och rum, men risken för mödradödlighet har hos vissa jägar- och samlarsamhällen skattats till drygt <a href="https://onlinelibrary.wiley.com/doi/10.1111/brv.12744">3 procent</a>.</p>
</div>
<div class="rest-of-article ">
<p>Men skillnaderna stannar inte där. Vi måste addera en enorm olikhet i produktionskostnad per könscell, där en hane producerar miljontals spermier för kostnaden av ett enda ägg – ja, asymmetrin i människans reproduktiva investering är betydande, men inte tillräckligt beskriven än. Evolutionen valde nämligen att placera mjölkautomaten på henne och inte på honom. Och utöver dessa kostnader skiljer sig könen även i längden på den fertila perioden, där kvinnans chans till avkomma är betydligt mer begränsad än mannens, både ur ett månatligt perspektiv med en cyklisk ägglossning, och över en livslängd med klimakteriet. Medan en man kan producera ett fyrsiffrigt antal barn hinner en kvinna aldrig få fler barn än vad som ryms inom det tvåsiffriga intervallet.</p>
<p>Män och kvinnor har av dessa anledningar olika optimala reproduktionsstrategier som genererar vad vi evolutionsbiologer kallar för <em>sexual conflicts</em> eller könskonflikter.</p>
<h2>Det evolutionära perspektivet uteblir ofta</h2>
<p>Dessa konflikter utgör piedestalen som anatomiska, fysiologiska och psykologiska könsskillnader vilar på. Trots det hör man i princip aldrig om det evolutionära perspektivet när könsfrågor diskuteras.</p>
<p>Det råder idag en alltmer tilltagande relativisering och förnekelse av biologiska könseffekter. Inget får vara fixerat, allt ska vara föränderligt och kunna anpassas efter individens känslor. Och när biologin ger sig till känna, så som delar av verkligheten tenderar att göra, då attackeras och ändras semantiken, juridiken och pedagogiken.</p>
<p>Queerteori med <strong>Judith Butlers</strong> idé om att kön bara är en social konstruktion, hyllas och accepteras, även inom akademins väggar. Vi ser en explosionsartad ökning av barn och ungdomar som söker vård för könsdysfori, det vill säga känslan av att vara född med fel kön. Under de senaste tio åren har antalet unga som söker vård för problemet ökat med <a href="https://lakartidningen.se/klinik-och-vetenskap-1/kommentar/2019/10/okningen-av-konsdysfori-hos-unga-tarvar-eftertanke/">2 300 procent</a> i Sverige och med över <a href="https://www.telegraph.co.uk/politics/2018/09/16/minister-orders-inquiry-4000-per-cent-rise-children-wanting/">4 000 procent</a> i England. Vad som orsakat denna dramatiska ökning är inte helt känt, men <a href="https://lakartidningen.se/klinik-och-vetenskap-1/kommentar/2019/10/okningen-av-konsdysfori-hos-unga-tarvar-eftertanke/">kulturbunden psykologisk smitta</a> via exempelvis sociala medier förklarar förmodligen en del av trenden. Att organisationer och förbund som RFSL och Transammans numera arrangerar transkollon för barn säger en del om situationen. På RFSL:s <a href="https://rfslungdom.se/transkollo/">hemsida</a> läser jag ”max 12 år (vi har ingen undre åldersgräns)”.</p>
<p>Att vården av unga individer med könsdysfori har vilat på metoder som <a href="https://www.sbu.se/sv/publikationer/nya-vetenskap-och-praxis/konsdysfori-vetenskapligt-oklart-hur-unga-mar-pa-sikt/">saknar vetenskapligt stöd</a> och samtidigt kommer med en livslång biverkningslista, gör debatten och kritiken än viktigare. Vårdfrågan är betydande, inte minst då personer med könsdysfori löper en ökad risk för självmord. Om diagnosen könsdysfori bidrar till en ökad risk för dödlighet i suicid per se är dock en abstrakt fråga att svara på, eftersom samförekomsten av andra svåra psykiatriska diagnoser är <a href="https://www.socialstyrelsen.se/om-socialstyrelsen/pressrum/press/vanligt-med-flera-psykiatriska-diagnoser-hos-personer-med-konsdysfori/">mycket hög</a> hos de individer som tar sitt liv.</p>
<blockquote><p>Historiskt sett har medicinsk forskning vanligen bedrivits på män&#8230;</p></blockquote>
<p>Trots att den könskorrigerande vården med underlivskirurgi, pubertetshämmare och könskonträra hormoner saknar vetenskapligt stöd, hör man ofta diverse debattörer yrka på att behandlingsformen är en ”livsviktig vårdinsats”. Ordvalet ”livsviktig” syftar i denna kontext på en idé om att risken för självmord är högre om personer inte får tillgång till den ovannämnda invasiva vårdformen. Att så skulle vara fallet saknar inte bara vetenskapligt stöd, i värsta fall kommer motsatsen visa sig vara sann. I en svensk <a href="https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0016885">långtidsstudie</a> jämfördes exempelvis olika riskfaktorer mellan personer som genomfört könsbyte och  jämnåriga i normalpopulationen. Forskarna fann bland annat att uppföljningstiden efter könsbytet var förenad med en 19 gånger högre risk för självmord. Förutom en märklig situation inom vården, pågår en diskussion om en uppdatering av könstillhörighetslagen. Visionen är att självidentifikation ska ligga till grund för individens juridiska kön för att på så vis göra processen enklare. <a href="https://www.forskning.se/2016/02/15/ge-ratt-vard-kvinnors-och-mans-kroppar-reagerar-olika-pa-behandling/">Inom vården har en förnekelse av könets betydelse stått kvinnan dyrt</a>.</p>
<p>Historiskt sett har medicinsk forskning vanligen bedrivits på män, vilket lett till att mediciner feldoserats och symtom som är specifika för kvinnor förbisetts. Samtidigt som vården blivit bättre på att uppmärksamma dessa biologiska skillnader har en medveten förnekelse spridit sig till andra samhällsområden. Testa att googla ”<a href="https://www.google.com/search?client=safari&amp;rls=en&amp;q=who+menstruate%3F&amp;ie=UTF-8&amp;oe=UTF-8">who menstruate?</a>”.</p>
<p>I ett par månaders tid har nämligen det översta resultatet lytt som följer: ”Having a period is not a feminine thing, and people of all genders menstruate, including non-binary people, agender people and even plenty of men! Menstruation doesn&#8217;t change anything about your gender, it&#8217;s just a thing that some bodies do.” Jag misstänker att idén om att förneka skillnaden mellan män och kvinnor är sprungen ur en välvilja och vision om ökad jämställdhet. Om kön inte är biologiskt fixerat och om könsskillnader inte existerar, ja då försvinner ju strukturella orättvisor och patriarkatet. Men det är en tankevurpa. Att förneka verkligheten har aldrig gynnat någon och den pågående trenden i könsfrågan leder återigen till att kvinnorna får lida.</p>
<p>Exemplen är många, men för att nämna några: Unga flickor riskerar att få svårare att göra en idrottskarriär eftersom transkvinnor allt oftare intar den högsta pallplatsen. Ordet ”kvinna” anses numera vara ett exkluderande ord och tillämpas mer sällan till fördel för ”person med livmoder”.  Och hur kul är det att vara en kvinnlig intern när våldsbenägna män numera kan avtjäna sitt straff på kvinnoanstalter efter en självidentifiering som kvinna?</p>
<p>Det är dock inte enbart kvinnor som drabbas negativt av denna verklighetsförnekelse. Faktum är att män som grupp mår sämre än på länge. Samhället har förändrats och så har rollen som den manliga beskyddaren och försörjaren av familjen. I USA är kvinnan numera den huvudsakliga försörjaren i 40 procent av alla familjer – vilket är ett fantastiskt framsteg ur ett jämställdhetsperspektiv, för kvinnor. Men när den klassiska mansrollen försvinner faller meningen för mannen bort. Det så kallade ”<em>deaths of despair</em>” är <a href="https://bigthink.com/series/the-big-think-interview/male-inequality/">tre gånger vanligare</a> hos män än kvinnor.</p>
<p>Kikar man enkom på självmordsstatistiken så är även den tre gånger högre hos män än kvinnor och <a href="https://bigthink.com/series/the-big-think-interview/male-inequality/">forskning</a> har visat att dessa män ofta beskriver sig själva som meningslösa innan de avslutar allt. Detta är ett problem som alltför sällan diskuteras i offentligheten, förmodligen på grund av rädslan att bli stämplad som att vara på ”fel” sida av jämställdhetsdebatten. Jag vill dock mena att det inte borde finnas några sidor. På gruppnivå är män och kvinnor biologiskt olika och det är bara genom att acceptera denna verklighet som vi kan skapa ett jämställt samhälle. Ett förnekande av könsskillnader skadar, det är vetenskapligt inkorrekt och det är ett direkt hån mot vår evolutionära historia.</p>
<h2>Varför sexuell reproduktion?</h2>
<p>Vi tar det från början – via en tidsresa på sisådär två miljarder år. Här finner vi nämligen de <a href="https://www.science.org/doi/10.1126/science.324_1254">första exemplen</a> på sexuellt reproducerande organismer. Innan dess hade evolutionen endast bidragit med asexuell reproduktion. Så varför kön och varför sex? Om vi hade fått chansen att fråga dessa tidiga eukaryoter hade de kanske svarat: ”Det gäller att springa det fortaste man kan för att stå kvar på samma ställe.”</p>
<p>Den som läst <strong>Lewis Carrolls</strong> klassiker <em>Alice i Underlandet</em> känner kanske igen meningen från den röda drottningen. Och faktum är att vi finner ett av de starkaste argumenten för evolutionen av kön och sexuell reproduktion i den så kallade ”red queen hypothesis”.</p>
<p>Låt oss ta en parasit och en värd som exempel. Parasitens mål är att infektera värden, och värden måste lyckas försvara sig mot parasiten. Resultatet blir en evolutionär kapprustning mellan parasit och värd där de båda organismerna utvecklas så snabbt de kan, med resultatet att de upprätthåller ett förhållande till varandra i form av en evolutionär kapplöpning. Dylika kapplöpningar återfinns överallt i naturen där olika aktörer utgör pjäserna i det evolutionära spelet. Ett annat välkänt exempel är rovdjur och bytesdjur. Asexuell reproduktion är i alla dessa fall en urdålig strategi eftersom det endast leder till genetiska kloner av sig själv. Och det är just här som fördelen med kön och sexuell reproduktion kommer in i bilden – via ökad genetisk variation.</p>
<p>I en värld där de selektiva krafterna konstant förändras över tid och rum är variation en vinnande strategi, och sexuell reproduktion är därför allmänt förekommande hos djur, växter, svampar och protister.</p>
<blockquote><p>I en värld där honor väljer partner blir fler män än kvinnor barnlösa.</p></blockquote>
<p>Sexuell reproduktion medför dock många problem, som i sin tur leder till konflikter mellan könen. I stället för att leta efter mat måste du nu leta efter en potentiell partner, vilket tar tid och energi och kan leda till interaktioner med både rovdjur och patogener (sjukdomsorsakande mikroorganismer och virus). Och när du väl funnit en individ av motsatt kön som får dina själviska gener att jubla av åtrå, så är det sällan pang på rödbetan som gäller. Nej, då krävs insatser och styrkeprov för att framhäva dina unika fördelar. Tänk på tjurens horn hos de partåiga hovdjuren, tänk på en storvuxen laxhane som med lätthet jagar bort de andra hanarna från lekplatsen, tänk på de extrema <a href="https://www.youtube.com/watch?v=E1zmfTr2d4c">byggnadsverk</a> som hanarna hos lövsalsfåglarna konstruerar.</p>
<p>Tänk på Rolex, Ferrari, muskler, en skinnväst med ett Hells Angels-emblem eller varför inte social kompetens, en statusfylld arbetstitel, pengar på kontot eller hög intelligens – symboler och karaktärsdrag som signalerar ”jag är stark, mäktig och har resurser – jag kan ta hand om dina barn”.</p>
<p>I en värld där honor väljer partner blir fler män än kvinnor barnlösa och män med en förhållandevis låg utbildningsgrad och/eller låg yrkessocial rangordning är de som tenderar att bli förbisedda. Medan exempelvis ett akademiskt arbete ökar den svenska mannens chans till att bli förälder, förekommer ingen sådan koppling mellan föräldraskap och yrkesval hos jämnåriga kvinnor. Vidare driver ett honligt partnerval konkurrensen mellan hanar, vilket har varit en bidragande orsak till varför män som grupp uppvisar en betydligt större variation än kvinnor som grupp. Läs gärna vetenskapsjournalisten <strong>Henrik Höjers</strong> sammanfattning av denna forskning <a href="https://fof.se/artikel/2018/8/farre-man-blir-pappor/?fbclid=IwAR3euBJTdW0OBnuGAyK3Hcuiu97AXBzeSmKP2udllDSF2czXq9dNJnCMA9w">om partnerval och föräldraskap</a> och om hur <a href="https://kvartal.se/artiklar/inte-alla-man/">män är mer varierade än kvinnor</a>.</p>
<p>Och eftersom kvinnor tenderar att välja partner med preferenser för exempelvis <a href="https://www.sciencedirect.com/science/article/abs/pii/S1090513808000792">intelligens</a> och<a href="https://link.springer.com/article/10.1007/s12110-022-09422-2"> inkomst</a> är det inte heller konstigt att evolutionen av mänskliga kulturer tenderar att generera patriarkala strukturer. Men varför bara fokus på det honliga partnervalet? Svaret ligger i den där könskonflikten – den där orättvisan som föreligger mellan honor och hanar i produktionen av avkomma. Hon investerar ju inte bara mer energi än han, hon är också upptagen i tid av att vara gravid och ammande, vilket han slipper. För henne blir kvalitet viktigare än kvantitet, medan det motsatta kan vara evolutionärt sant för honom. Det finns givetvis undantag som bekräftar regeln, och för den som önskar förkovra sig går det att läsa mer om detta under <a href="https://sv.wikipedia.org/wiki/Batemans_princip">”</a><a href="https://sv.wikipedia.org/wiki/Batemans_princip">Batemans princip” </a>och ”<a href="https://en.wikipedia.org/wiki/Parental_investment">parental investment theory</a>”.</p>
<p>Vi kan dock inte lämna det honliga partnervalet utan att nämna hennes vision om ”<a href="https://en.wikipedia.org/wiki/Sexy_son_hypothesis">sexiga söner</a>”. Det är en evolutionsbiologisk idé som postulerar att det ideala partnervalet är det som genererar avkommor som i sin tur kommer att ha en relativt hög chans till reproduktiv framgång. I en värld där hanar konkurrerar om honor blir det ideala valet för en kvinna en man som anses vara synnerligen attraktiv. Med den Mendelska genetiken på sin sida kommer nämligen ett sådant val att generera söner som i sin tur kommer att anses vara attraktiva av den generationens honor. Och i det evolutionära spelet vinner den mormor som har flest barnbarn.</p>
<p>Nåväl, åter till problematiken med sexuell reproduktion. Som synes är sexuell reproduktion inte en helt problemfri lösning och det är allt som oftast många steg som ska uppfyllas innan den evolutionära klimaxpunkten nås – när könscellerna fusioneras och det genetiska materialet blandas till en ny, förhoppningsvis välanpassad avkomma. Men nog om sex på ett tag. Låt oss diskutera sakfrågan – kön.</p>
<h2>Ett könssystem är alltid binärt</h2>
<p>Kanske kan det förvåna någon som i vår postmoderna samtid blivit lurad till att tro att könssystemet är ett spektrum av <a href="https://72gender.com/72-genders-list/">72 olika varianter</a>, men nej – kön förekommer endast i två varianter – hona och hane vilka producerar ägg och spermier, respektive. Det maskineri som styr huruvida avkomman blir en hane eller hona förekommer dock i en mångfald.</p>
<p>Hos människan och insekter är lösningen könskromosomerna XX (hona) och XY (hane). Hos många fåglar är det i stället könskromosomerna ZZ (hane) och ZW (hona). Könskromosomer är dock inte allt. Hos vissa arter, exempelvis bland ödlor och fiskar, kan miljövariabler reglera vilket kön individen får.</p>
<blockquote><p>Fiskar är nog den djurgrupp där evolutionen av kön tagit flest vägar.</p></blockquote>
<p>Ett extremt exempel på detta finner vi hos ödlan skäggagam, där den omgivande temperaturen kan överskrida betydelsen av könskromosomerna. I en <a href="https://www.nature.com/articles/nature14574">studie</a> fann man ödlor som såg ut som honor men hade kromosomuppsättningen för en hane (ZZ), men det riktigt anmärkningsvärda var att dessa genetiskt kodade hanar dessutom kunde producera avkommor som en hona. Ett system där höga temperaturer selekterar ut hanar kan såklart vara negativt under rådande klimatförändringar – men det är en annan artikel.</p>
<p>Fiskar är nog den djurgrupp där evolutionen av kön tagit flest vägar. Här är det som kallas sekventiell hermafrodism relativt vanligt (det vill säga byte av kön under individens livstid). <a href="https://www.instagram.com/p/CbAzmwXLcM0/">Blågyltan</a> – en av Sveriges vackraste fiskarter, har utvecklat en sådan strategi. De är protogyna hermafroditer vilket innebär att alla föds som honor men med förmågan att transformera sig själv till hane när plikten kallar, det vill säga när gruppens dominanta hane avlidit. Jag har på sistone noterat att dylika system används för att marknadsföra idén om att transsexualitet skulle vara vanligt förekommande i djurriket.</p>
<p>Faktum är att jag nyligen noterade att organisationen RFSL spred den typen av desinformation på sina sociala medier. På Instagram konstaterade de att ”Det är sedan länge vetenskapligt klarlagt att trans inte bara är en mänsklig verklighet, utan också finns i tusentals andra djurarter”. Att exempelvis fiskar som blågyltan kan byta kön under sin livstid betyder inte att det har någon som helst inverkan på deras upplevelse av könstillhörighet. Det kan inte ens anses sannolikt att förmågan till en sådan upplevelse i någon form överhuvudtaget existerar hos andra arter än vår egen.</p>
<p>Det står därför i stor kontrast till det vi människor skulle kalla transsexualitet – vilket är upplevelsen av att vara född i fel kropp. I ärlighetens namn förstår jag inte hur en fråga om transsexualitet hos icke-mänskliga djurarter ens skulle kunna testas, hur skulle metoden i sådana vetenskapliga studier se ut?</p>
<p>Eftersom kön är ett binärt system genererar det alltid mer eller mindre optimala strategier för honor och hanar. Med olika optimala strategier uppstår konflikter mellan könen. Och som evolutionspsykologen <strong>David Buss</strong> <a href="https://journals.sagepub.com/doi/10.1177/0963721417695559">belyser</a> kan vi upptäcka sådana konflikter före, under och efter parningsprocessen. För att förstå detta i mer detalj tänker jag att vi återigen ska spola tillbaka bandet för att göra ett besök hos våra närmaste kusiner. Innan vi fortsätter in i primatbiologins värld har jag av erfarenhet fått för mig att ett förtydligande kan vara på sin plats.</p>
<p>Inte minst om du som läsare tror på en allsmäktig skapare och tycker att ett besök på <a href="https://en.wikipedia.org/wiki/Ark_Encounter">Ark Encounter</a> är utbildning. Vi kommer inte från aporna – vi är apor. Vi kommer inte från schimpanserna – vi delar en gemensam förfader som levde <a href="https://www.nature.com/articles/nature04789">för cirka 6 miljoner år sedan</a>. Därefter har våra evolutionära vägar sett lite olika ut. Schimpanserna, som lever norr om Kongofloden, är dock inte vår enda riktigt närbesläktade kusin. Vi har också en släkting på södra sidan floden: bonobon. Ur ett genetiskt perspektiv är det inte så mycket som skiljer oss från dem, <a href="https://www.nature.com/articles/nature11128">nära 99 procent</a> av schimpansens och bonobons arvsmassa delas med oss. Många forskare menar därför att vi har mycket att lära genom att studera de sociala konstruktioner, beteenden, kunskaper och dynamiker som förekommer i de tropiska skogarna kring Kongofloden.</p>
<p>Låt oss därför åka på en liten släktträff.</p>
<h2>Ett besök hos våra kusiner</h2>
<p>Morfologiskt är våra kusiner väldigt lika varandra. Bonobon är till storleken mindre än schimpansen, de har också ett mörkare ansikte och längre hår som ofta är friserat i en snygg mittbena. Ur ett socialt perspektiv råder det dock diametrala skillnader. Schimpansen förekommer som sagt på den norra sidan av Kongofloden där den lever i patriarkala samhällen, medan bonobon existerar söder om floden i tydligt matriarkala system. Schimpanshanar styr ofta gruppens honor med järnhand och vill det sig riktigt illa kan kontakten med vuxna hanar leda till infanticid, det vill säga mord på honans barn.</p>
<blockquote><p>Naturen är obehaglig och obekväm, men lika sann för det.</p></blockquote>
<p>Och inte sällan äter hanarna upp avkomman – att slösa på näring är dumt när konkurrensen om föda är stor. Extremt brutalt i våra ögon, men ur ett evolutionärt perspektiv kan det vara en god strategi. Förfarandet slår nämligen ut den konkurrerande hanens gener ur genpolen och reducerar på så vis också konkurrensen för ”gärningsmannen” och dennes avkomma. Dessutom kan honan bli tillgänglig för parning snabbare om hon inte har ungar att vakta. Utöver barnadråp är aggressiva utfall och våldtäkter inte alltför ovanliga företeelser hos denna kusin. Naturen är obehaglig och obekväm, men lika sann för det.</p>
<figure id="attachment_101449" aria-describedby="caption-attachment-101449" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-101449 size-full" src="https://kvartal.se/wp-content/uploads/2023/07/sdlAk6vDlTsnfY-nl.jpg" alt="" width="1024" height="786" data-wp-pid="101449" srcset="https://kvartal.se/wp-content/uploads/2023/07/sdlAk6vDlTsnfY-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/07/sdlAk6vDlTsnfY-nl-600x461.jpg 600w, https://kvartal.se/wp-content/uploads/2023/07/sdlAk6vDlTsnfY-nl-300x230.jpg 300w, https://kvartal.se/wp-content/uploads/2023/07/sdlAk6vDlTsnfY-nl-768x590.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-101449" class="wp-caption-text">En sju dagar gammal bonobo sover efter att ha diat. Foto: Michael Probst /TT</figcaption></figure>
<p>Men nog om patriarkatet. Låt oss blicka söderut, mot vår storleksmässigt mindre kusin. Bonobon upptäcktes sent av vetenskapen. Första indikationen på artens förekomst gjordes på ett museum i Belgien år 1929, då den tyske zoologen <strong>Ernst Schwarz</strong> konstaterade att primatskallen som undersöktes var synnerligen liten för att tillhöra en vuxen individ. Fyra år senare klassificerade vi bonobon som en egen art. Med sitt lättsamma beteende, sexuellt jämställda samhälle, kvinnliga sammanhållning och nästintill frånvarande våldskapital har de fascinerat forskare i olika discipliner. Arten karakteriseras bäst som kvinnocentrerad och egalitär. Mycket talar för att bonobon ersatt aggression med sex. Exempelvis har dödligt våld eller barnadråp aldrig observerats hos denna art. Och medan sex hos de flesta andra arter utförs för att generera avkomma är det i ett bonobonsamhälle en integrerad del av sociala relationer – och då inte bara mellan honor och hanar.</p>
<p>Till skillnad från schimpanser som nästan aldrig har sex med ögonkontakt intar bonobon en position där ansikte står mot ansikte i en betydande del av alla kopulationer.</p>
<p>De sysslar också med sex före maten. Mat är resurser och resurser leder till konkurrens och konkurrens kan leda till bråk. Sex tros här utgöra en form av <a href="https://www.sciencedirect.com/science/article/pii/0162309594900388">konflikthantering</a> kring denna annars så riskfyllda konkurrenssituation. Bortom aggression och sex förekommer ytterligare tydliga skillnader kusinerna emellan. <a href="https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0051922">Experimentella försök </a>har visat att bonoboer av olika åldrar gärna delar med sig av mat och de delar den till och med villigt med främlingar, vilket indikerar att altruism inte är unikt för människan. Man har kunnat uppmäta distinkta skillnader mellan schimpanser och bonoboer för en mångfald av variabler, såsom reaktioner mot <a href="https://www.pnas.org/doi/10.1073/pnas.1007411107">stress och konkurrens</a>, <a href="https://www.pnas.org/doi/10.1073/pnas.1522060113">känslouttryck</a> och <a href="https://www.pnas.org/doi/full/10.1073/pnas.2201122119">sociala system</a>, för att nämna några.</p>
<p>Ur ett kognitivt perspektiv har forskarna kunnat <a href="https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0012438">konstatera</a> att bonoboer, i jämförelse med schimpanser, har en högre förståelse för social kausalitet och är skickligare på att lösa uppgifter relaterade till ”<em><a href="https://sv.wikipedia.org/wiki/Inlevelsef%C3%B6rm%C3%A5ga">theory of mind</a></em>&#8221;, det vill säga förmågan att kunna sätta sig in i en annan individs perspektiv. Schimpanser är å andra sidan skickligare på uppgifter som kräver användning av verktyg och har en högre förståelse för fysisk kausalitet. Vänta nu – låter inte detta som en klassisk psykologisk beskrivning av det vi anser vara stereotypiskt kvinnligt och manligt hos vår egen art?</p>
<p>Den uppenbara frågan är såklart – hur blev det så här? Varför denna enorma skillnad i sociala system?</p>
<p>Även om perioder av <a href="https://onlinelibrary.wiley.com/doi/10.1111/j.1365-294X.2004.02332.x">genflöde ägt rum</a> mellan våra kusiner har Kongofloden utgjort en fysisk barriär som förhindrat individer av de båda arterna att träffas. För en miljon år sedan drabbades området av en <a href="https://onlinelibrary.wiley.com/doi/10.1002/evan.21456">långvarig torka</a>, vilket orsakade en matbrist som drev bort förfäderna till dagens gorillor från den södra sidan av floden. När torkan sedan upphörde och växtligheten tilltog var mellanartskonkurrensen borta och det fanns mat i överflöd, vilket reducerade incitament för aggressiva beteenden. I stället för våld blev vänlighet och samarbete de mest eftertraktade egenskaperna söder om floden. De honor som hade flest vänner hade de bästa chanserna till överlevnad eftersom de kunde gå samman för att kontrollera de till storleken större hanarna, och genom att luta sig mot sina utökade sociala nätverk började honor få övertaget.</p>
<p>På norra sidan av floden var förhållandena helt annorlunda. Förfäderna till områdets schimpanser delade sin ekologiska nisch med lokala bestånd av gorillor. Konkurrensen om de få resurser som fanns var hård. För att överleva i en sådan miljö krävdes färdigheter för fysisk kamp. Hanar med ett djärvt sinne och en adekvat mängd muskelmassa lyckades roffa åt sig resurser. För en hona var den evolutionärt bästa strategin att villigt eller ovilligt para sig med dessa konkurrenskraftiga hanar, eftersom det innebar resurser och skydd för sig och sina avkommor.</p>
<p>Så vad kan vi lära oss av allt detta? Massor! Norr om Kongofloden, där konkurrensen var stenhård blev råstyrka en central egenskap – vilket även innebar att de starkaste hanarna helt enkelt tvingade sig på honorna för att övervinna deras ovilja att para sig. Paradoxalt nog kan detta ses som positivt även för den ovilliga honan eftersom hennes avkomma kommer att ärva faderns karaktärsdrag, vilket i en dylik miljö kan ge evolutionära fördelar. Hos den matriarkala bonobon hyser hanarna stor respekt för honorna. Detta märks exempelvis under födosök <a href="https://onlinelibrary.wiley.com/doi/10.1002/ajp.20387">då hanarna ger företräde åt honorna</a>.</p>
<p>Att vara en respektfull gentleman uppskattas av gruppens honor och tros vara en bidragande del när det kommer till hennes val av partner.</p>
<p>När det kommer till att ta hand om avkomman verkar ansvaret hos bonobon ligga uteslutande på honornas axlar. Kärnfamiljer är förmodligen oförenliga med det mångsidiga användandet av sex som återfinns hos arten. Hos oss människor är ju mannens investering i familjen en strategi för att minska den evolutionära könskonflikten som uppstår ur kvinnans relativt höga reproduktiva kostnader. Ett sådant system hade dock aldrig utvecklats om vi män inte hade kunnat vara rimligt säkra på att det är våra egna, och inte någon annans, avkommor. Medan våra båda kusiner saknar en sådan garanti, skyddar vi människor familjens integritet med diverse moraliska restriktioner och tabun.</p>
<h2>Män och kvinnor reagerar olika på fara</h2>
<p>Konflikten mellan könens olika optimala strategier må vara grundade i den reproduktiva delen av en individs livscykel, men effekterna sprider sig långt utanför. Livet handlar ju inte enbart om att reproducera sig. Man ska ju överleva också.</p>
<p>Och när det kommer till överlevnad har hungriga rovdjur haft en signifikant kraft i det naturliga urvalet av fenotyper. För att reducera risken att bli föda åt någon annan har evolutionen givit oss den så kallade stressaxeln (<a href="https://en.wikipedia.org/wiki/Hypothalamic%E2%80%93pituitary%E2%80%93adrenal_axis">HPA-axeln</a>) – ett <a href="https://academic.oup.com/edrv/article/21/1/55/2423840?login=false">fysiologiskt försvar</a> som via ökad produktion och frisättning av diverse ämnen, däribland stresshormonet kortisol – förbereder oss för &#8221;fight-or-flight&#8221; eller ”fly-eller-fäkta”. Flertalet moderna studier har dock visat att det ofta finns stora skillnader i hur hanar och honor reagerar på hot om fara. Det finns idag tämligen starkt stöd för att stressystemet skiljer sig på ett könsspecifikt manér, där fight-or-flight anses vara en typiskt hanlig variant av stressrespons. I stället för att fly sin väg eller bekämpa/slåss mot sin fiende, har honor utvecklat en reaktion som i högre grad gynnar avkomman, en så kallad ”<a href="https://psycnet.apa.org/doiLanding?doi=10.1037%2F0033-295X.107.3.411">tend-and-befriend</a>” eller <span style="color: #ff0000;"><span style="color: #000000;">”vårda-och-var-vän</span></span>”-strategi.</p>
<blockquote><p>Biologiska könsskillnader är verkliga.</p></blockquote>
<p>Ur ett fysiologiskt perspektiv tror man att detta system är mer drivet av oxytocin och honliga könshormoner, som till viss del verkar dämpande på HPA-axeln. Förstå mig rätt, honor har även de en förmåga att producera stresshormoner som kortisol och är givetvis fullt förmögna att både fly och fäkta. Men att fly eller fäkta är en relativt individualistisk strategi som på grund av den där orättvisa reproduktiva investeringen leder till att det är en sämre strategi för honor. Könsspecifika skillnader i stressystemet tycks vara någorlunda generella i djurens rike.</p>
<p>Jag har även i min egen <a href="https://academic.oup.com/evolut/article/77/1/304/6873661">forskning</a> sett sådana resultat.</p>
<p>När jag exponerade individer av fiskarten ruda för en hungrig rovfisk i en kontrollerad laboratoriemiljö fann jag att hanarna uppreglerade uttrycket av gener relaterade till den klassiska stressaxeln, medan honorna visade en nedreglering av samma gener. <strong><a href="https://en.wikipedia.org/wiki/Shelley_E._Taylor">Shelley E. Taylor,</a></strong> som lade fram idén om könsspecifika stressreaktioner hos människan, förklarar ”tend” som de vårdande aktiviteter som görs för att skydda sig själv men också avkomman och ”befriend” som skapandet och upprätthållande av sociala nätverk som under en farlig situation kan vara till hjälp. Att kvinnor på gruppnivå är bättre på omsorg och sociala beteenden är förmodligen ingen nyhet för någon.</p>
<h2>Verkligheten är inte ett farligt vapen</h2>
<p>Biologiska könsskillnader är verkliga. Faktum är att kön sticker ut som en signifikant faktor för en uppsjö av egenskaper hos alla sexuellt reproducerande organismer. Men det finns de som inte vill att dessa skillnader ska exponeras i det offentliga. Efterdyningarna av <strong>Belinda Olssons</strong> SVT-serie <a href="https://www.svt.se/kultur/feministprofilernas-kritik-mot-nya-programmet-om-kon-vad-ska-det-vara-bra-for"><em>Från savannen till Tinder</em></a> var ett tydligt bevis på detta. Programmet byggde på intervjuer med både tänkare och tyckare.</p>
<p>I det förstnämnda klientelet fann vi bland annat psykiatrikern och hjärnforskaren <strong>Markus Heilig</strong>, som representerade det naturvetenskapliga perspektivet. Och vad vore public service utan <strong>Agnes Wold</strong>? Hon må vara professor och tillika läkare, men i den här serien var hon den tvärsäkra ledaren för tyckar-klientelet. Wold menade att biologisk vetenskap inte är något man ska tala högt om eftersom det är ett ”farligt vapen”. När Belinda Olsson ifrågasätter Wolds ideologiska perspektiv och menar att ett erkännande av våra olikheter skulle kunna leda till en positiv utveckling för båda könen, svarar Wold snabbt: <a href="https://www.svt.se/kultur/feministprofilernas-kritik-mot-nya-programmet-om-kon-vad-ska-det-vara-bra-for">“Det är en väldigt naiv tanke.”</a></p>
<p>Det är anmärkningsvärt att en professor i medicin uppmanar till ett ideologiskt grundat verklighetsförnekande i statsfinansierad television.</p>
<figure id="attachment_101450" aria-describedby="caption-attachment-101450" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-101450 size-full" src="https://kvartal.se/wp-content/uploads/2023/07/sdlrwJ2L2p_U08-nl.jpg" alt="" width="1024" height="683" data-wp-pid="101450" srcset="https://kvartal.se/wp-content/uploads/2023/07/sdlrwJ2L2p_U08-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/07/sdlrwJ2L2p_U08-nl-600x400.jpg 600w, https://kvartal.se/wp-content/uploads/2023/07/sdlrwJ2L2p_U08-nl-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2023/07/sdlrwJ2L2p_U08-nl-768x512.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-101450" class="wp-caption-text">Agnes Wold. Foto: Adam Ihse/TT</figcaption></figure>
<p>Nåväl, hur var det med efterdyningarna? Jo, i <a href="https://www.aftonbladet.se/kultur/a/XqoLkm/svt-pratar-biologism-och-ramlar-ner-i-1900-talet">Aftonbladet</a> använde journalisten <strong>Ulrika Stahre</strong> begrepp som ”ramla ner i 1900-talet” och ”en konservativ våg” för att beskriva serien. <strong>Malin Krutmeijer</strong> tar verklighetsförnekandet ännu längre och skriver i <a href="https://www.sydsvenskan.se/2021-08-17/svts-nya-serie-om-konsskillnader-liknar-rena-konspirationsfilmerna">Sydsvenskan</a> att den naturvetenskapliga beskrivningen av könsskillnader kan ses som rena konspirationsteorierna. Jag håller varken med Wold, Stahre eller Krutmeijer – ett förnekande av verkligheten är aldrig rätt väg att gå. Vi tillhör riket animalia, stammen ryggsträngsdjur, klassen däggdjur, ordningen primater, familjen hominider, släktet människor. Förekomsten av fenotypiska skillnader mellan individer av de båda könen hör till den äldsta och mest uppenbara formen av biologisk kunskap.</p>
<p>Det kulturella försöket att fly verkligheten gör samhället mindre jämställt och hade fått våra kusiner att skratta högt.</p>
<h2>Vad är en kvinna?</h2>
<p>Könsskillnader försvinner inte bara för att vi ändrar semantiken, juridiken eller pedagogiken. Queerrörelsens syn på kön som en social konstruktion har varit förvånansvärt framgångsrik att sprida sig som en alternativ form av sanning. Det västerländska förnekandet av kön har gått så långt att folk idag har svårt att redogöra för innebörden av ordet kvinna.</p>
<p>Fram tills nyligen har svaret varit så uppenbart att frågan inte förekommit i någon annan kontext än pekböcker för barn yngre än två år. Nu är kulturen annorlunda och vuxna högutbildade människor famlar i ovisshetens land så fort frågan kommer upp. Ett av de mer välkända exemplen på hur man kan kuggas i denna basala fråga fick vi från <strong>Ketanji Brown Jackson</strong> under förra året. Vi talar nu om en domare i USA:s högsta domstol som alltså inte vet vad en kvinna är. Varför hon inte vet menar <a href="https://www.youtube.com/watch?v=BWtGzJxiONU">Ketanji själv beror på att hon inte är biolog</a>. Och kanske var det just avsaknaden av en biologiutbildning som fick Nya Zeelands premiärminister <strong>Chris Hipkins</strong> att drabbas av tunghäfta följt av ångest och ett inkorrekt svar när han nyligen <a href="https://www.youtube.com/watch?v=PnSB5uT65aM">fick frågan</a>.</p>
<p>Vill man ha fler exempel på just detta kan jag varmt rekommendera dokumentärfilmen ”<a href="https://www.imdb.com/title/tt20256528/">What is a woman?”</a>. Till försvar för dem som inte längre tycks veta vad en kvinna är kan det nämnas att  <a href="https://dictionary.cambridge.org/dictionary/english/woman">Cambridge dictionary</a> uppdaterade betydelsen av orden ”kvinna/man” i slutet av 2022. Den nya definitionen lyder: ”en vuxen person som lever och identifierar sig som en hona/hane, trots att de vid födseln kan ha tilldelats det motsatta könet”. Vi har alltså en situation där semantiken men inte verkligheten tillåter en pojke att växa upp till en kvinna och en flicka till en man. Och kanske är det just dylika försök till manipulation av verkligheten som gör att ingen längre tycks kunna svara på de mest enkla av frågor?</p>
<p>Verklighetsförnekandet har även spridit sig in i akademin. I mitt eget forskningsfält finns exempelvis ”<a href="https://www.eeblanguageproject.com/">the Ecology and Evolutionary Biology language project</a>”. Syftet är att reducera skadliga ord inom den vetenskapliga litteraturen. Det är ett seriöst projekt som till och med lyckats <a href="https://www.cell.com/trends/ecology-evolution/fulltext/S0169-5347(22)00359-7">publicera</a> sina tokiga idéer i en av fältets högst rankade tidskrifter. På deras hemsida kan man finna en <a href="https://www.eeblanguageproject.com/repository">tabell</a> där flertalet skadliga ord är listade. I en kolumn bredvid de skadliga orden kan man finna förslag på ersättningsord, som då enligt personerna bakom projektet ska utgöra mindre smärta för läsaren. Och nu följer lite sedvanlig woke-logik: Orden ”man” och ”woman” anses vara ”harmful terms” och skadar läsaren genom att vara ”antropomorfiska med fördel för manliga individer” och ska därför ersättas.</p>
<p>Förslag på ersättning är ”male”, ”female” eller ”human”. Men! Om man scrollar lite längre ner i listan så hamnar man i en återvändsgränd, för där dyker nämligen orden ”male”/”female” upp i kolumnen för skadliga ord. Argumentet lyder: ”These terms are used to reinforce societally-imposed ideas of a sex binary, emphasising cis-normative and hetero-normative views.” Nu till det bästa av allt. Ersättningsorden för ”male” och ”female” är … trumvirvel … ”sperm-producing”/”egg-producing” or ”XY individual”/”XX individual”. Här kanske den observanta läsaren stannar upp och tänker att det är något som inte riktigt stämmer. Och ja, jag håller med – de alternativa orden är exakt lika binära som ”male”/”female”. Detta är ett av många exempel på hur den nutida verklighetsförvrängningen i slutändan bara leder till rappakalja.</p>
<p>Det är märkligt. Å ena sidan har vi förmodligen aldrig förnekat existensen av biologiska könseffekter till den grad vi gör idag, å andra sidan har förekomsten av transsexuella barn och ungdomar ökat <a href="https://www.theguardian.com/society/2022/nov/24/an-explosion-what-is-behind-the-rise-in-girls-questioning-their-gender-identity">explosionsartat</a>. I en <a href="https://publications.aap.org/pediatrics/article/147/6/e2020049823/180292/Prevalence-of-Gender-Diverse-Youth-in-an-Urban?autologincheck=redirected">studie</a> fann forskarna att nära tio procent av skolungdomarna identifierade sig med en annan könstillhörighet än sitt biologiska kön. Eftersom standardbehandlingen är invasiv och inkluderar både medicin och kirurgi är dylika siffror minst sagt oroväckande. Som tur är har åtminstone Sverige vaknat i frågan kring vården av dessa individer.</p>
<h2>Kan man födas i fel kropp?</h2>
<p><a href="https://lakartidningen.se/aktuellt/nyheter/2021/05/karolinska-satter-stopp-for-hormonbehandling-vid-konsdysfori/">Karolinska Institutet har sedan en tid slutat</a> experimentera på barnens bekostnad, och i december 2022 gick Socialstyrelsen ut med <a href="https://www.socialstyrelsen.se/om-socialstyrelsen/pressrum/press/uppdaterat-kunskapsstod-for-vard-vid-konsdysfori-hos-unga/">nya nationella riktlinjer</a> där man inte längre rekommenderar könsbekräftande kirurgi, pubertetshämmande medicinering och könskonträra hormonbehandlingar för ungdomar under 18 år. Vilket inte var en dag för tidigt, eftersom behandlingsformen <a href="https://www.sbu.se/sv/publikationer/nya-vetenskap-och-praxis/konsdysfori-vetenskapligt-oklart-hur-unga-mar-pa-sikt/">aldrig haft vetenskapligt stöd</a>.</p>
<p>Trist för läkemedelsbolagen som tjänar <a href="https://nypost.com/2021/08/20/gender-ideology-a-boon-to-big-pharma-and-threat-to-parental-rights/">enorma summor</a> pengar på den moderna transvården, men en enorm <a href="https://nypost.com/2022/06/18/detransitioned-teens-explain-why-they-regret-changing-genders/">vinst för ungdomarna</a>.</p>
<p>Inte minst eftersom könsdysfori tenderar att <a href="https://www.jaacap.org/article/S0890-8567(08)60142-2/fulltext">försvinna efter puberteten</a>. Övergången från barn till vuxen är en stor och övergripande fenotypisk förändring för individen, där olika versioner av identitetskriser är en vanlig och allmänt accepterad biverkning. En gissning är att den pågående marknadsföringen om att barn och unga ska upprätthålla en kritisk syn på sin könsidentitet, har drivit upp antalet falskt positiva fall av diagnosen könsdysfori. Sisådär ett <a href="https://lakartidningen.se/klinik-och-vetenskap-1/kommentar/2019/10/okningen-av-konsdysfori-hos-unga-tarvar-eftertanke/">par tusen procent</a>. För faktum är att genuspedagogik och queerteori har implementerats i förskolor, skolor och sociala medier över samma tidsperiod. En kritiker kanske dömer ut mig som transfob för en sådan kausal gissning. Fast vänta lite nu. Det förekommer väl ingen skillnad mellan könen? Så varför ska barn och unga ens behöva fundera över sin könsidentitet? Och varför kirurgi, pubertetshämmande mediciner och testosteron eller östrogen när biologi inte har någon effekt? Och varför erbjuder vården bara byte mellan två kön när kön inte är ett binärt system utan ett spektrum av varianter? Eller varför inte bryta ner det i grunden med att ställa frågan om varför transsexualitet ens förekommer hos vår art när biologiska könsskillnader inte existerar?</p>
<blockquote><p>Mig veterligen finns det inga övertygande data som ger stöd för idén om att man kan födas i fel kropp.</p></blockquote>
<p>Det jag försöker belysa med mina smått satiriska frågor är att det just nu råder en sällan skådad dissonans hos ett betydande, högljutt klientel människor som å ena sidan förnekar biologiska könsskillnader och det binära system som kön faktiskt är, å andra sidan skriker sig hesa för att barn och unga ska ha rätten till könsbekräftande vård och självidentifiering av sitt juridiska kön (helst från och med 12 års ålder) trots att både vården och lagen endast tillämpar det binära systemet: hona och hane.</p>
<p>Jag vill här passa på att betona att det förekommer individer vars kombination av könskromosomer inte följer det klassiska XX/XY-mönstret. Tillstånden jag syftar på går in under termen ”intersex” och inkluderar exempelvis Klinefelters syndrom (en eller fler extra X-kromosomer hos hanar) och Turners syndrom (avsaknaden av en X-kromosom hos honor).</p>
<p>Skattningar har visat att förekomsten av intersex är ungefär <a href="https://pubmed.ncbi.nlm.nih.gov/12476264/">0,018 procent</a> av populationen.</p>
<p>Vidare finns det andra tillstånd av intersex där uppsättningen könskromosomer följer det normala men där andra genetiska mutationer genererar missbildningar i reproduktionsorganen. Ett ovanligt exempel är <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2844757/">Persistent müllerian duct syndrom</a> som gör att pojkar (XY) kan födas med inre kvinnliga reproduktionsorgan (inklusive livmoder, äggledare och vaginala delar) samtidigt som de yttre reproduktionsorganen är könstypiska. Ibland används dylika tillstånd som ett argument för spektrum-hypotesen, vilket såklart är ett fullkomligt ogiltigt argument eftersom produktionen av könsceller hos dessa individer är antingen ägg eller spermier, aldrig ”äggmier” eller ”sperägg” eller vad nu teoretiska könsceller utanför det binära systemet kan tänkas heta.</p>
<p>Även individuella variationer i könshormoner kan av genusvetaren eller queerteoretikern användas som bevis för spektrum-hypotesen. Dylikt resonemang är inte bara biologiskt inkorrekt, det är även synnerligen problematiskt eftersom det riskerar att skapa en tro på att individer är mer eller mindre man eller kvinna baserat på nivåerna av testosteron respektive östrogen.</p>
<p>Jag förringar inte upplevelsen av könsdysfori hos barn och ungdomar. Tillståndet är verkligt för dessa individer, men om tillståndet ur ett mekanistiskt perspektiv skiljer sig från hur exempelvis en anorektiker alltid, oavsett vikt, upplever sig vara tjock låter jag vara osagt. Att en individ kan födas i ”fel kropp” är en underlig idé som kräver en solid vetenskaplig grund för att kunna accepteras. Jag tänker på ett citat från <strong>Carl Sagan</strong>: ”extraordinary claims require extraordinary evidence”. Mig veterligen finns det inga övertygande data som ger stöd för idén om att man kan födas i fel kropp. Vidare är frågan svår att testa ur ett vetenskapsteoretiskt perspektiv eftersom konceptet könsidentitet är direkt sprunget ur individens personliga upplevelse av sig själv, och sanningshalten i en individs självupplevelse går inte att falsifiera av någon annan än individen själv. Det är därför märkligt att fenomenet accepterats som en sanning. Och var börjar och slutar acceptansen för ett självidentifierande system?</p>
<p>Det finns förmodligen människor vilka identifierar sig som katt, hund, T-rex eller sjöjungfru. Vidare finns det säkert en hel del gamla individer som identifierar sig som unga och det finns vita som identifierar sig som svarta. Min fördom är att många människor accepterar idén om att man kan vara född med fel kön, men väldigt få skulle acceptera andra fenotypiska dysforier. Varför kan man födas med könsdysfori men inte artdysfori, åldersdysfori eller melanindysfori? Jag menar, en vit person som identifierar sig som svart har endast fel uppfattning om sin epidermala melanin-variant, vilket ur ett biologiskt perspektiv har en försumbar betydelse i jämförelse med kön. Detta tål att funderas på, inte minst eftersom en selektiv acceptans av fenotypisk dysfori saknar logik och vetenskaplig grund.</p>
<p>Baserat på dagens kunskapsläge är det svårt att acceptera idén om att en individ kan födas i fel kropp. Förekomsten av könsdysfori är empiriskt belagd men mig veterligen finns det inga data som ger stöd för att denna dysfori vore orsakad av något annat än en psykologisk ”mismatch” mellan individens personlighet och rådande könsnormer i den aktuella kulturen. När vi accepterar idén om att individer kan födas med fel kön, accepterar vi också ett angrepp mot de drabbade individernas kroppar (ordagrant nuförtiden). För mig känns det betydligt mer moraliskt att försöka skapa acceptans för den biologiska kroppen än att bekräfta en idé om att någons medvetande existerar i fel kropp. Inte minst när könsbyte är en omöjlighet. Varför inte attackera den satta kulturen i stället för individens biologi?</p>
<h2>Varför förnekar vi könsskillnader?</h2>
<p>År 2016 släppte Utbildningsradion (UR) den pedagogiska serien ”100 frågor om sex” som är tänkt att utgöra undervisningsmaterial för svensk skola. I avsnitt 48 får vi höra <strong>Vierge Hård</strong> från RFSL <a href="https://urplay.se/program/196751-100-fragor-om-sex-kan-man-fa-orgasm-om-man-genomgatt-underlivskirurgi">sälja in underlivskirurgi</a> för elever i årskurs 7–9. Två år senare publicerade UR nytt pedagogiskt material för svensk skola och för dina skattemedel. Serien ”Snacka om sex” består passande nog av sex olika avsnitt och riktar sig till skolungdomar i en ålder av 11–13 år.</p>
<p>I <a href="https://urplay.se/program/209998-snacka-om-sex-kroppen">avsnitt tre</a> får man lära sig att man ”inte måste vara kille bara för att man är född med snopp. Eller tjej för att man är född med snippa”. I samma avsnitt får vi träffa en tjej som aldrig kommer att få mens. Aj då, arma flicka som föddes med något fel i livmodern eller äggstockarna, tänker man. Men nejdå, flickan som aldrig kommer att få mens hette <strong>Vicktor</strong> fram till högstadiet och har snopp. Men den ska hon operera bort i framtiden. Till programserien följer också en <a href="https://www.ur.se/mb/pdf/handledningar/211000-211999/211327-3_Snacka_om_sex_3_handledning_kroppen.pdf">lärarhandledning</a> där eleverna uppmanas att komma på frågor om könsidentitet, något som givetvis förutsätter att man tänkt på sin egen.</p>
<p>I kontrast till detta och som ett svar på en falsk pedagogik publicerade läkaren <strong>David Eberhard</strong> samma år boken <em>Det stora könsexperimentet</em>. Han belyste bland annat förskolornas tillämpande av ordet hen i stället för pojke och flicka som exempel på hur långt det gått. Nu, sisådär fem år senare, har det eskalerat. Vissa akademiker har slutat använda ordet ”kvinna” till fördel för ”person med kapacitet att bli gravid”, då ordet kvinna ”<a href="https://www.nbcnews.com/nbc-out/out-politics-and-policy/law-professor-khiara-bridges-calls-sen-josh-hawleys-questions-pregnanc-rcna38015">is transphobic and can open up trans people to violence</a>”.</p>
<p>I Sverige har genuspedagogiken fortsatt påverka skolsystemet, exempelvis är ”<a href="https://kvartal.se/artiklar/nina-rungs-akademiska-luftslott/">genusvetaren” <strong>Nina Rung</strong></a> författare till den nya läroboken <em>Sexualitet, samtycke och relationer: en lärobok som gör svåra samtal lättare</em>. <a href="https://kvartal.se/artiklar/sa-blev-sex-och-samtycke-del-av-alla-amnen/#_ftn30">”Kön”, förklarar Rung, ”är inte något man är utan något man gör oberoende av ens biologiska kropp – något som en skapar själv och det är inte kopplat till det biologiska könet.”</a> Att honor är honor och att hanar är hanar och att det föreligger betydande skillnader mellan de båda har fram tills nyligen varit en så uppenbar sanning att det varit en icke-fråga.</p>
<p>Så hur kommer det sig att planetens smartaste organism har så svårt att erkänna sådan basal kunskap? Jag menar att svaret är tredelat.</p>
<p>Den första delen innebär en förnekelsekonsensus gällande vårt ursprung. Att människan, likt varenda organism som någonsin existerat och någonsin kommer att existera, är en produkt av organisk evolution via naturlig selektion är en sanning som de flesta sällan viger en tanke åt. Den västerländska människan tenderar att se sig själv på en piedestal ovanför övriga jordbor. Detta är en falsk bild av vår plats i naturen som förmodligen initierades dagen då våra förfäder skapade gudar.</p>
<blockquote><p>Patriarkatet försvinner inte för att vi förnekar skillnader mellan könen.</p></blockquote>
<p>Den andra delen av svaret finner vi i att vi har det för bra. Vi behöver inte backa bandet vidare långt innan vi når en tid då vi alla bar samma dagliga bekymmer som planetens övriga arter. Att skaffa mat, skydda oss från rovdjur, finna en partner, reproducera oss och ta hand om avkomman är problem som vår hjärna anpassat sig för att lösa. I takt med ökad välfärd har dessa tidigare bekymmer reducerats och för många av oss är det numera icke-problem. Vi har lyxen att kunna ta självaste livet för givet och med det kommer friheten att kunna så och skörda illusioner och lögner såsom frånvaron av biologiska könsskillnader.</p>
<p>Den tredje och kanske viktigaste delen av svaret ligger i ett försök att generera ett jämställt samhälle. Den västerländska kulturen har likt många andra av människans kulturer kantats av ett patriarkalt styre. Jag misstänker att man i egalitära stater som Sverige har försökt reducera patriarkatet genom att blunda för biologin. Om kön inte är biologiskt fixerat och om könsskillnader inte existerar, ja då försvinner patriarkatet på kuppen.</p>
<p>Men med facit i hand har förnekandet av biologin knappast varit en gynnsam metod. <strong>William Thomas</strong>, numer känd som <strong>Lia Thomas</strong>, står <a href="https://www.insider.com/trans-swimmer-lia-thomas-beats-olympic-medalists-wins-ncaa-title-2022-3">högst upp på pallen</a> och ser ner på de konkurrerande simmerskorna. <strong>Kristoffer Johansson</strong>, som dömdes till tio års fängelse för att ha dödat och styckat sin exflickvän, avtjänar sitt <a href="https://www.expressen.se/nyheter/krim/raseri-i-kvinnofangelset-hotade-honom-till-livet/">straff på kvinnofängelse</a> under namnet <strong>Kim Marie</strong>. Samtidigt kräver svenska politiker och organisationer som <a href="https://www.rfsl.se/verksamhet/trans/oppet-brev-till-statsministern-om-behovet-av-en-ny-konstillhorighetslag/">Amnesty och RFSL</a> att få till en ändrad könstillhörighetslag så att det ska bli enklare att ändra juridiskt kön.</p>
<h2>Idén om tabula rasa är falsifierad, om och om igen</h2>
<p>Bortsett från könskromosomer är det betydande <a href="https://www.cell.com/cell-reports/fulltext/S2211-1247(20)30776-2?_returnURL=https%3A%2F%2Flinkinghub.elsevier.com%2Fretrieve%2Fpii%2FS2211124720307762%3Fshowall%3Dtrue">skillnader i genuttryck mellan män och kvinnor</a> – skillnader som visat sig förekomma i mer eller mindre alla typer av vävnader, inte minst i livmodern och prostatan. Vi finner könsspecifika skillnader i <a href="https://www.pnas.org/doi/full/10.1073/pnas.1633678100">kroppsstorlek</a>, <a href="https://bmjopen.bmj.com/content/8/3/e018697">syreupptagningsförmåga</a>, <a href="https://link.springer.com/article/10.1007/BF00235103">muskelmassa och styrka</a>. <a href="https://psykologtidningen.se/2021/04/20/konsskillnad-vid-autism-aterspeglas-i-hjarnan/">Autism är vanligare hos pojkar/män</a> och de typiska karaktärsdragen <a href="https://lakartidningen.se/opinion/debatt/2022/10/varden-ar-for-dalig-pa-att-upptacka-autism-hos-flickor-och-kvinnor/">skiljer sig ofta från flickors/kvinnor</a>s. Detsamma gäller för <a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3379858/">psykopati</a>. Symtom på somatiska sjukdomar skiljer sig inte alltför sällan mellan könen. <a href="https://www.internetmedicin.se/behandlingsoversikter/kardiologi/hjartinfarkt-hos-kvinnor/">Kvinnor uppvisar exempelvis en bredare och mer atypisk symptombild på hjärtinfarkt än män</a>. På grund av receptorskillnader i kropp och knopp kan doseringen av mediciner behöva anpassas mellan män och kvinnor även efter att korrigering gjorts för kroppsvikt. Är man biomedicinsk analytiker till vardags kan jag tänka mig att biologiska könsskillnader är en självklarhet, eftersom mängder av olika serum- och plasmaprover har könsspecifika referensvärden. Detta är bara ett axplock av en uppsjö biologiska könsskillnader.</p>
<p>Likt många före mig vill jag påstå att jämställdhet uppnås genom att vi ser verkligheten för vad den är. Patriarkatet försvinner inte för att vi förnekar skillnader mellan könen. Det är i vår biologi vi finner svaren för äkta jämställdhet. Vi föds inte som oskrivna blad – vi har våra förfäders historia i vårt DNA och dessa historier bär ett könsspecifikt arv. Genom att acceptera de evolutionära skillnaderna mellan män och kvinnor kan vi bättre förstå hur könsspecifika styrkor och svagheter kan tillämpas, i stället för att dämpas eller elimineras. Och det är kanske just därför vi ibland bör påminna oss om våra kusiner.</p>
<p>I ljuset av varandra är nämligen schimpansen och bonobon en fin skildring av varför vår jämställdhet varit en svårslagen evolutionär strategi. Förmågan som gjort människan unik i sitt slag kan till stor del förklaras av samarbete – ett jämställt samarbete som i de flesta kulturer grundar sig på monogami och delad omvårdnad av djurrikets minst självständiga avkomma. Det är via detta samarbete som den evolutionära konflikten mellan könen reduceras så att 1 + 1 blir 3.</p>
<h2>Skäggiga kvinnor</h2>
<p>Jag sitter på min sons fotbollsträning och scrollar nyheterna på mobilen. ”<a href="https://nypost.com/2023/03/30/male-powerlifter-enters-womens-event-breaks-record/">Male powerlifter enters women’s event, breaks record</a>”. Den nya rekordhållaren för bänkpress i kvinnoklassen heter <strong>Avi Silverberg</strong> och är man. Han slog rekordet med nästan 45 kg och hade dagen till ära inte ens brytt sig om att raka av sig skägget. Förklaringen till skägget ligger i att hela insatsen var en protest mot Canadian Powerlifting Unions <a href="https://www.canadianpowerliftingunion.com/_files/ugd/fa7009_12a406a2fa1447568f9a688464464562.pdf">anti-diskrimineringsregel</a> som gör att alla, oavsett kön, kan tävla i kvinnoklassen så länge man identifierar sig som kvinna.</p>
<p>Jag läser vidare om hur den tidigare rekordhållaren <strong>Anne Andres</strong> var på plats och reagerade ilsket över att en skäggig man nu gått in på kvinnornas arena och tagit rekordet. Har man följt transdebatten senaste åren är detta inget konstigt – alltså att män börjar erövra kvinnoidrotten. Men vad jag fann anmärkningsvärt med just denna nyhet är att den förra rekordhållaren, som nu blev vansinnig på att en skäggig man gick in och tog kvinnornas rekord i bänkpress, också var en man som sedan ett gäng år tillbaka identifierat sig som kvinna, en så kallad transkvinna.</p>
<p>Jag stänger telefonen, tittar upp på fotbollsplanen och noterar att Lunds pojkar -14 enbart (som namnet antyder) består av pojkar. Efter träningen äter jag en sen middag med min son. Plötsligt kläcker han ur sig att en pojke som tar många sprutor kan bli en flicka. Förvånad över sambandet med artikeln jag läste under hans träning svarar jag honom med ett bestämt ”nej”. Han kontrar med: ”Jo, det är sant. Typ alla på min skola säger så.”</p>
<p>Jag fångar hans blick över middagsbordet och tänker att nu borde den där artikeln jag filat på så länge skrivas.</p>
<div class="author-byline">Jerker Vinterstare har en doktorsexamen i evolutionsbiologi från Lunds universitet och arbetar idag som forskare.
</div>
</div>

Redan prenumerant? Logga in här
Just nu:
Testa gratis
i 4 månader!
i 4 månader!
Ingen bindningstid
- Alla artiklar
- Alla poddar
- Kvartals app
- Reklamfritt
Till erbjudandet
