Av Lapo Lappin | 27 september 2023
I korthet
Jag tittar länge på de färgglada prickarna på skärmen. Efter att datorprogrammet analyserat Camilla Läckbergs samtliga romaner står resultaten tydliga.
Två titlar av Camilla Läckberg – Kvinnor utan nåd och Gå i fängelse – står en bit ifrån de andra. De är sannolikt skrivna av någon annan, enligt datorprogrammet. Det innebär i så fall att Camilla Läckberg har spökskrivare.
Det är ett anmärkningsvärt resultat i sig. Men programmet går ett steg längre. Det pekar ut vem den egentliga författaren till Kvinnor utan nåd med största sannolikhet är.
Stilometri
<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-108475"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="108475" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9haV92aXNhcl9kZV9oYXJfcm9tYW5lcm5hX2F2X2xhY2tiZXJnX2FyX3Nwb2tza3Jpdm5hLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvanItbGFwcGluLWFpLXZpc2FyLWRlLWhhci1yb21hbmVybmEtYXYtbGFja2JlcmctYXItc3Bva3Nrcml2bmEubXAz">  <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: "><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%2Fai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna%2F&amp;t=AI+visar%3A+De+h%C3%A4r+romanerna+av+L%C3%A4ckberg+%C3%A4r+sp%C3%B6kskrivna"    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=AI+visar%3A+De+h%C3%A4r+romanerna+av+L%C3%A4ckberg+%C3%A4r+sp%C3%B6kskrivna+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna%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%2Fai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=AI visar: De här romanerna av Läckberg är spökskrivna&body=https://kvartal.se/artiklar/ai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/108475/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/108475/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo&nbsp;Lappin</a> | 27 september 2023<div class="author-desc">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna%2F&amp;t=AI+visar%3A+De+h%C3%A4r+romanerna+av+L%C3%A4ckberg+%C3%A4r+sp%C3%B6kskrivna"    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=AI+visar%3A+De+h%C3%A4r+romanerna+av+L%C3%A4ckberg+%C3%A4r+sp%C3%B6kskrivna+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna%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%2Fai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=AI visar: De här romanerna av Läckberg är spökskrivna&body=https://kvartal.se/artiklar/ai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/108475/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/108475/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/ai-visar-de-har-romanerna-av-lackberg-ar-spokskrivna/?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 16 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/108475"    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-108475">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "108475"></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 ">Jag tittar länge på de färgglada prickarna på skärmen. Efter att datorprogrammet analyserat <strong>Camilla Läckbergs</strong> samtliga romaner står resultaten tydliga.</p>
<p>Två titlar av Camilla Läckberg – <em>Kvinnor utan nåd </em>och <em>Gå i fängelse </em>– står en bit ifrån de andra. De är sannolikt skrivna av någon annan, enligt datorprogrammet. Det innebär i så fall att Camilla Läckberg har spökskrivare.</p>
<p>Det är ett anmärkningsvärt resultat i sig. Men programmet går ett steg längre. Det pekar ut vem den egentliga författaren till <em>Kvinnor utan nåd</em> med största sannolikhet är.</p>
<h2>Stilometri</h2>
</div>
<div class="rest-of-article ">
<p>Föreställ dig att en pappersbunt dunkar ned i brevlådan en dag. Du plockar upp den och bläddrar igenom den.</p>
<p>Orden på manuskriptet består av bokstäver som någon har klippt ut ur en tidning och klistrat samman. Det finns inga ledtrådar till vem författaren är: inget handskrivet, inga fingeravtryck. Ingen returadress.</p>
<p>Men trots allt detta, hade man ändå kunnat lista ut författarens identitet? Svaret är ja.</p>
<p>Detta är i alla fall grundpremissen för det vetenskapliga fältet vid namn ”stilometri”. Stilometrin är studiet av författares stil, deras språk. Sättet på vilket vi skriver – vilka ord vi använder och när – skiljer sig från person till person, likt ett fingeravtryck. Varje persons ordval är unikt.</p>
<p>Trots att forskare inom fältet har gjort stora vetenskapliga framsteg är stilometri tämligen okänt för den breda allmänheten.</p>
<p>En serie av 85 politiska insändare som publicerades i New York-tidningar 1788, kända som <em>The Federalist Papers</em>, undertecknades med pseudonymen ”Publius”. Bakom denne Publius gömde sig tre amerikanska grundlagsfäder: <strong>John Jay</strong>, <strong>James Madison</strong> och <strong>Alexander Hamilton</strong>, som så småningom erkände vilka artiklar var och en av dem hade författat. Tolv av insändarna gjorde emellertid både James Madison och Alexander Hamilton anspråk på. Efter att ha förbryllat generationer historiker löstes gåtan 1963 av två amerikanska professorer, <strong>Fredrick Mosteller</strong> och<strong> David Wallace.</strong></p>
<blockquote><p>Metoden bedöms vara så tillförlitlig att stilometri används av säkerhetstjänster och polis för att hitta gärningsmän, baserat på deras stilistiska avtryck.</p></blockquote>
<p>Mosteller och Wallace var dock inte historiker. De var statistiker. Och de närmade sig gåtan med statistiska verktyg. Metoden gick ut på att hitta vems stil artiklarna med okänd författare liknade mest. De räknade hur många gånger den okända författaren använde vissa utvalda ord: ”funktionsord” som <em>while</em>, <em>upon</em>, <em>whatever</em> – ord som man använder nästan omedvetet. Sedan jämförde de hur ofta dessa till synes obetydliga ord förekom i artiklar som hade en bekräftad författare, antingen Madison eller Hamilton. När resultaten räknades ihop stod svaret tydligt: James Madison hade författat alla tolv.<sup>1</sup></p>
<p>På 1960-talet utfördes stilometriska undersökningar genom att långsamt räkna ord för hand. Med saxen i hand klippte Mosteller och Wallace ut orden ett efter ett från varsin kopia av breven. Därefter sorterades urklippen i alfabetisk ordning. Forskarduon skriver att ”under denna operation kunde en djup suck skapa en storm av konfetti, och en fiende för livet”.<sup>2</sup> Processen tog sammanlagt tre år.</p>
<p>Idag tar det några sekunder, tack vare digitaliseringen. Stilometriska datorprogram är numera tillgängliga för allmänheten att ladda ned och använda. De kan analysera miljoner faktorer under några sekunder, och utföra mer komplexa beräkningar. Metoden bedöms vara så tillförlitlig att stilometri används av säkerhetstjänster och polis för att hitta gärningsmän, baserat på deras stilistiska avtryck.<sup>3</sup></p>
<h2>Stylo avslöjar spökskrivarna</h2>
<p>Jag väljer ut ett sådant stilometri-program, Stylo, designat av tre välansedda stilometri-forskare, Maciej Eder, Mike Kestemont och Jan Rybicki. Stylo har använts för att knäcka gåtan om vem som gömmer sig bakom pseudonymen <strong>Elena Ferrante</strong>. (All stilistisk evidens pekar på en lingvistikprofessor från Neapel, <strong>Domenico Starnone</strong>.)<sup>4</sup></p>
<p>Jag ger mig ut på jakt efter<strong><span style="color: #0000ff;"> </span></strong>en svensk litterär gåta att testa metoden på. Det är då jag ramlar över författaren <strong>Håkan Lindgrens</strong> uppmärksammade roman <em>Spökskrivaren </em>(2021). En av protagonisterna i boken är den svenska deckardrottningen ”Milli Månsson”, som slutat att skriva sina egna böcker och delegerat arbetet till en spökskrivare. Man kan lugnt säga att karaktären påvisar vissa likheter med en annan – verklig – deckardrottning: Camilla Läckberg, som omgärdats av rykten om spökskrivare. Läckberg har passerat milstolpen 30 miljoner sålda böcker i världen, och varje ny titel kan därför inbringa stora summor.</p>
<figure id="attachment_108501" aria-describedby="caption-attachment-108501" style="width: 1905px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-108501 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/Lackberg-beskuren-instagram.jpg" alt="Läckberg kommenterade boken Spökskrivaren på Instagram. Skärmdump: Instagram." width="1905" height="1251" data-wp-pid="108501" srcset="https://kvartal.se/wp-content/uploads/2023/09/Lackberg-beskuren-instagram.jpg 1905w, https://kvartal.se/wp-content/uploads/2023/09/Lackberg-beskuren-instagram-1536x1009.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/09/Lackberg-beskuren-instagram-600x394.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/Lackberg-beskuren-instagram-300x197.jpg 300w, https://kvartal.se/wp-content/uploads/2023/09/Lackberg-beskuren-instagram-768x504.jpg 768w" sizes="(max-width: 1905px) 100vw, 1905px" /><figcaption id="caption-attachment-108501" class="wp-caption-text"><em>Läckberg kommenterade boken Spökskrivaren som en ”underhållande satir” på Instagram. Skärmdump: Instagram.</em></figcaption></figure>
<p>Ryktena avvisades då av Läckbergs förläggare på Forum, <strong>Ebba Östberg</strong>, som kommenterade i en TT-artikel: ”Det är väldigt mycket blod, svett och tårar inblandade i Camillas skrivande. Hon är en väldigt hårt arbetande människa, en av de mest hårt arbetande som jag någonsin träffat.”</p>
<p>Stilometri har såvitt jag vet aldrig tidigare använts i Sverige för att hitta spökskrivare, men det lämpar sig väl för uppgiften. Programmet räknar ihop de vanligaste orden i en text, processar dessa genom statistiska metoder och sammanställer sedan resultaten i ett diagram. I diagrammet kan man se ”avståndet” mellan olika stilar. Ju mer olika stil böcker har, desto längre ifrån varandra kommer de att hamna.</p>
<p>Vi kan ta som exempel den världsberömda deckarserien <em>Millennium,</em> som inleddes 2005 med <strong>Stieg Larssons </strong>postuma verk <em>Män som hatar kvinnor.</em> Larssons tre böcker följdes av ytterligare en trilogi av deckarförfattaren <strong>David Lagercrantz</strong>, och nu senast en bok av <strong>Karin Smirnoff</strong>. Om man lägger in dessa sju böcker i serien i Stylo och mäter de 1 000 vanligaste orden får man följande resultat.</p>
<p><a href="https://kvartal.se/wp-content/uploads/2016/03/1di.png"><img decoding="async" class="alignnone wp-image-108626 size-full" src="https://kvartal.se/wp-content/uploads/2016/03/1di.png" alt="" width="1343" height="1266" data-wp-pid="108626" srcset="https://kvartal.se/wp-content/uploads/2016/03/1di.png 1343w, https://kvartal.se/wp-content/uploads/2016/03/1di-600x566.png 600w, https://kvartal.se/wp-content/uploads/2016/03/1di-300x283.png 300w, https://kvartal.se/wp-content/uploads/2016/03/1di-768x724.png 768w" sizes="(max-width: 1343px) 100vw, 1343px" /></a></p>
<p>Trots att det rör sig om böcker i samma genre, till och med i samma bokserie, med en liknande uppsättning karaktärer, kan man se tydliga skillnader i stilen.</p>
<p>Som en lek med tanken kan man föreställa sig ett parallellt universum där <em>Millennium</em>-seriens förlag beslutar att vaktbytet var för riskabelt ur PR-synvinkel. Förlaget beslutar att det är bättre att fortsätta ge ut samma böcker under Stieg Larssons namn och kokar ihop en historia om att man hittade ytterligare sex manuskript i en dammig kista på Larssons vind.</p>
<p>Trots att det då hade stått ett och samma namn på omslagen skulle vi ha kunnat se spår av tre distinkta stilar, vilket i sin tur pekat på tre olika författare.</p>
<p>Om Camilla Läckberg hade haft spökskrivare borde man kunna se något liknande. Jag matar in de elva böckerna i Läckbergs bästsäljande <em>Fjällbacka</em>-serie tillsammans med verk av fem andra svenska deckarförfattare:<strong> Liza Marklund</strong>, <strong>Lars Kepler, Sofie Sarenbrant</strong>, David Lagercrantz och Stieg Larsson. Läckbergs böcker samlar ihop sig i ett kluster i nedre hörnet till vänster.</p>
<p><a href="https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01.png"><img decoding="async" class="alignnone wp-image-108636 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01.png" alt="" width="1669" height="1920" data-wp-pid="108636" srcset="https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01.png 1669w, https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01-1335x1536.png 1335w, https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01-600x690.png 600w, https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01-261x300.png 261w, https://kvartal.se/wp-content/uploads/2023/09/David-Lagercrantz-01-768x883.png 768w" sizes="(max-width: 1669px) 100vw, 1669px" /></a></p>
<p>Metoden i analysen heter multidimensionell skalning, en visuell representation av olikheter mellan olika objekt på ett diagram.<sup>5</sup></p>
<p>Diagrammet visar att alla böcker i <em>Fjällbacka</em>-serien delar ungefär samma kännetecknande stil. Det är stark evidens <em>mot</em> hypotesen att Läckberg använt en spökskrivare för att skriva sina böcker om Fjällbacka.</p>
<p>För att vederlägga spökskrivarryktena bortom allt tvivel införskaffar jag böckerna som Camilla Läckberg har skrivit utöver <em>Fjällbacka</em>-serien. 2019 släppte Läckberg två kortromaner med titlarna <em>Kvinnor utan nåd</em> och <em>Gå i fängelse</em>, också kända som <em>Hämnd</em>-serien. Kortromanerna släpptes också i en samlingsvolym som sålde över 100 000 exemplar.<sup>6</sup> Samma år lanserade Läckberg en ny serie, <em>Fayes hämnd</em>, med böckerna <em>En bur av guld</em> (2019) och <em>Vingar av silver </em>(2020)<em>. </em>När jag matar in dessa fyra böcker i programmet händer någonting annorlunda.</p>
<p><a href="https://kvartal.se/wp-content/uploads/2016/03/3di.png"><img decoding="async" class="alignnone wp-image-108624 size-full" src="https://kvartal.se/wp-content/uploads/2016/03/3di.png" alt="" width="1283" height="1186" data-wp-pid="108624" srcset="https://kvartal.se/wp-content/uploads/2016/03/3di.png 1283w, https://kvartal.se/wp-content/uploads/2016/03/3di-600x555.png 600w, https://kvartal.se/wp-content/uploads/2016/03/3di-300x277.png 300w, https://kvartal.se/wp-content/uploads/2016/03/3di-768x710.png 768w" sizes="(max-width: 1283px) 100vw, 1283px" /></a></p>
<p>I detta diagram ser vi plötsligt något nytt. Liksom i det tidigare experimentet hopar sig <em>Fjällbacka</em>-böckerna över varandra i en blå mylla. Men de nya böckerna följer inte mönstret. Såväl titlarna i <em>Hämnd-</em>serien som de i <em>Fayes hämnd </em>hamnar rätt långt bort från Läckbergs kännetecknande stilavtryck. Romanerna i <em>Fayes hämnd</em>: <em>En bur av guld</em> och <em>Vingar av silver</em>, har liknande stil, en bit bort från Läckbergs övriga böcker. <em>Kvinnor utan nåd</em> och <em>Gå i fängelse</em>, däremot, hamnar på helt olika sidor i diagrammet, båda långt bort från Läckbergs vanliga stil.</p>
<p>Kan det bara handla om att det är andra serier, som använder olika ord? Innan jag utförde experimentet strök jag alla ord som kunde vara ledtrådar till en viss roman. Ord som ”Faye”, ”Erica”, ”Fjällbacka”, ”Patrik” eller ”Revenge”. Det avgörande är hur någon använder små ord, de anspråkslösa språkdelarna som brukar rusa förbi obemärkta: ”och”, ”det”, ”att”, ”på”, ”i” (för att ta Läckbergs vanligaste ord som exempel).</p>
<h2>En möjlig kandidat</h2>
<p>Kan stilbrotten i Läckbergs böcker vara spår som den beryktade spökskrivaren har lämnat efter sig? Jag hittar en intervju om spökskrivare med Camilla Läckberg i <em>Aftonbladet</em>. Intervjuaren nämner ett rykte om att Läckbergs hemliga spökskrivare skulle ha varit en viss <strong>Pascal Engman</strong>. Engman, tidigare journalist på Expressen, har också blivit en framgångsrik deckarförfattare, känd för sin serie om polisinspektören<strong> Vanessa Frank</strong>. Läckberg svarar <em>Aftonbladet</em> att Engman enbart arbetat som hennes redaktör, ”och inget annat än just det”, något som Engman bekräftar för tidningen. Reportern frågar: Hur mycket har du själv jobbat med spökskrivare?</p>
<p>”Inte mycket, hahaha. Jag har för mycket kontrollbehov”, svarar Läckberg.</p>
<p>I <em>En bur av guld</em> tackar hon Pascal Engman för att vara en ”galet begåvad kollega” som har ”givit viktig input när jag behövt bolla tankar om karaktärerna”. I uppföljaren <em>Vingar av silver</em> tackas han som ”vän och författarkollega”, för att ha ”tillfört både briljans och engagemang vid bollandet av idéer”. I kortromanen <em>Kvinnor utan nåd </em>tackas den ”überbegåvade” Engman, ”som varit en klippa och ett bollplank i tillkomsten av dessa böcker”.</p>
<p>Kan Pascal Engman vara en spökskrivare som hemsöker Camillas Läckbergs böcker? Jag lägger in Engmans debut <em>Patrioterna</em> (2017) samt de fem böckerna i Engmans <em>Vanessa Frank-</em>serie i programmet, tillsammans med böcker av Camilla Läckberg, Sofie Sarenbrant och Lars Kepler. Programmet mäter de 1 000 vanligaste orden i de olika böckerna.</p>
<p><img decoding="async" class="alignnone wp-image-108646 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/Fjallbacka-03-01.png" alt="" width="1825" height="1920" data-wp-pid="108637" srcset="https://kvartal.se/wp-content/uploads/2023/09/Fjallbacka-03-01.png 1825w, https://kvartal.se/wp-content/uploads/2023/09/Fjallbacka-03-01-1460x1536.png 1460w, https://kvartal.se/wp-content/uploads/2023/09/Fjallbacka-03-01-600x631.png 600w, https://kvartal.se/wp-content/uploads/2023/09/Fjallbacka-03-01-285x300.png 285w, https://kvartal.se/wp-content/uploads/2023/09/Fjallbacka-03-01-768x808.png 768w" sizes="(max-width: 1825px) 100vw, 1825px" /></p>
<p>Här slingrar sig Pascal Engmans romaner längs samma ungefärliga axel i den nedre delen av diagrammet. De lägger sig nära Camilla Läckbergs kortroman <em>Kvinnor utan nåd</em>. Enligt Stylo är det alltså mer sannolikt att Pascal Engman står bakom <em>Kvinnor utan nåd </em>än att Camilla Läckberg gör det. De två romanerna i <em>Fayes</em> <em>hämnd </em>är ungefär mitt emellan Camilla Läckbergs kluster och Pascal Engmans. Kortromanen <em>Gå i fängelse</em> är fortfarande långt bort från båda, vilket tyder på att varken Engman eller Läckberg är författaren.</p>
<p>Pascal Engman själv mejlar att han har arbetat som redaktör för <em>Kvinnor utan nåd</em>, <em>En bur av guld</em> och <em>Vingar av silver</em>. Han skriver:</p>
<p>”Alla som har gett ut en bok vet att det är en redaktörs jobb att arbeta med författarens text på olika sätt. För tydlighetens skull dementerar jag bestämt det du insinuerar.”</p>
<h2>Testar resultaten i maskininlärningsprogram</h2>
<p>För att få mer klarhet byter jag till ett annat stilometri-program, JGAAP. Stilometri-experten bakom programmet, den amerikanske professorn i datavetenskap <strong>Patrick Juola</strong>, skapade rubriker världen över när han med hjälp av det AI-drivna programmet JGAAP kunde avslöja vem som gömde sig bakom pseudonymen <strong>Robert Galbraith</strong>, författare till deckaren <em>A Cuckoo&#8217;s Calling</em> (2013)<em>. </em>Det visade sig vara ett välbekant namn: Harry Potter-författaren <strong>J.K. Rowling</strong>.<sup>7</sup></p>
<p>Jag vill se om resultatet i JGAAP kan bekräfta eller vederlägga det från Stylo.</p>
<p>Jag lägger in fyrtio böcker av åtta bästsäljande deckarförfattare som jag har samlat: Camilla Läckberg <em>(Fjällbacka</em>-serien), Sofie Sarenbrant, David Lagercrantz, Stieg Larsson, Lars Kepler, Liza Marklund, Pascal Engman samt <strong>Denise Rudberg</strong>.<sup>8</sup></p>
<blockquote><p>Analysen pekar otvetydigt på Engman, och inte Läckberg, som den riktiga författaren till <em>Kvinnor utan nåd</em>.</p></blockquote>
<p>Det första jag vill göra är att testa hur pålitliga resultaten är. Programmet kan utföra experiment med olika parametrar: inte bara de vanligaste orden, utan även de vanligaste orden i följd, de vanligaste tecknen i följd, ordlängd, meningslängd, sällsynta ord och så vidare.</p>
<p>Jag plockar ut en bok i taget för att se om programmet kan gissa vem författaren är baserat på de vanligaste orden i författarens övriga verk. Den träffar rätt 40 av 40 gånger. Programmet kan alltså skilja mellan författarnas olika stilar med väldigt hög precision.</p>
<figure id="attachment_108499" aria-describedby="caption-attachment-108499" style="width: 800px" class="wp-caption alignnone"><img decoding="async" class="wp-image-108499 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/Magnus-Ranvid-https___www.bonnierforlagen.se_wp-content_uploads_sites_4_2021_03_camillalackberg-prm.webp" alt="" width="800" height="540" data-wp-pid="108499" srcset="https://kvartal.se/wp-content/uploads/2023/09/Magnus-Ranvid-https___www.bonnierforlagen.se_wp-content_uploads_sites_4_2021_03_camillalackberg-prm.webp 800w, https://kvartal.se/wp-content/uploads/2023/09/Magnus-Ranvid-https___www.bonnierforlagen.se_wp-content_uploads_sites_4_2021_03_camillalackberg-prm-600x405.webp 600w, https://kvartal.se/wp-content/uploads/2023/09/Magnus-Ranvid-https___www.bonnierforlagen.se_wp-content_uploads_sites_4_2021_03_camillalackberg-prm-300x203.webp 300w, https://kvartal.se/wp-content/uploads/2023/09/Magnus-Ranvid-https___www.bonnierforlagen.se_wp-content_uploads_sites_4_2021_03_camillalackberg-prm-768x518.webp 768w" sizes="(max-width: 800px) 100vw, 800px" /><figcaption id="caption-attachment-108499" class="wp-caption-text"><em>Från pressreleasen av den sammanslagna pappersutgåvan av kortromanerna ”Gå i fängelse” och ”Kvinnor utan nåd”. Foto: Magnus Ranvid/Forum Förlag. </em></figcaption></figure>
<p>Jag samlar Läckbergs fyra böcker <em>Kvinnor utan nåd</em>, <em>Gå i fängelse, En bur av guld</em> och <em>Vingar av silver </em>i programmet<em>. </em>Sedan låter jag maskinen räkna ut vem av mina åtta författare som mest sannolikt har skrivit dessa böcker.</p>
<p>Boken som får tydligast resultat är kortromanen <em>Kvinnor utan nåd</em>. Programmet väljer Engman över Läckberg som den mest sannolika författaren, inte bara när det kommer till de vanligaste orden, utan även andra parametrar. Analysen pekar otvetydigt på Engman, och inte Läckberg, som den riktiga författaren till <em>Kvinnor utan nåd</em>.</p>
<p>Stilen i <em>Gå i fängelse</em>, däremot, bedöms överensstämma mest med Sofie Sarenbrant och Lars Kepler, sedan Pascal Engman, och först därefter Läckberg. Det betyder inte att en av dessa är författaren, utan att stilen liknar dem mest i urvalet av verk som använts för experimentet. Det är dock relevant att Läckberg rangordnas förvånansvärt lågt i de olika parametrarna, ibland till och med sist. Sammanvägt tyder JGAAP:s värdering på att författaren till <em>Gå i fängelse </em>varken är Läckberg eller Engman, utan någon annan.</p>
<p>I såväl <em>En bur av guld</em> som <em>Vingar av silver</em> bedöms Camilla Läckberg som den mest sannolika författaren. Men även här är resultatet intressant: Båda texterna bedöms samtidigt ligga nära Pascal Engmans stil. För vissa parametrar och för vissa delar av <em>Vingar av silver</em> pekar programmet ut Engman som författaren.</p>
<p>Resultaten från AI-programmet JGAAP:s analys av Camilla Läckbergs böcker är:</p>
<ul>
<li><em>Kvinnor utan nåd</em>: Författad av <strong>Pascal Engman.</strong></li>
<li><em>Gå i fängelse</em>: Författad av en <strong>okänd</strong> <strong>spökskrivare</strong> (varken Camilla Läckberg eller Pascal Engman).</li>
<li><em>En bur av guld</em>: Huvudförfattare är <strong>Camilla Läckberg</strong>, men bedöms samtidigt ligga nära Pascal Engmans stil.</li>
<li><em>Vingar av silver</em>: Huvudförfattare är <strong>Camilla Läckberg</strong>, men bedöms samtidigt ligga nära Pascal Engmans stil.</li>
</ul>
<p>Men vad betyder det att <em>En bur av guld </em>och <em>Vingar</em> <em>av silver </em>ligger närmare Engmans stil, trots att Läckberg bedöms som huvudförfattaren? Engman och Läckbergs stilar är inte speciellt lika, åtminstone inte i den utsträckningen att programmet kan blanda ihop dem. JGAAP lyckas annars skilja på Läckberg och Engmans böcker i samtliga fall. Det är också osannolikt att Läckberg skulle ha ”bytt” stil till något som mer liknar Pascal Engmans. <em>Fjällbacka</em>-seriens senaste bok, <em>Gökungen</em> (2022), gavs ut efter böckerna i <em>Fayes hämnd.</em> Men stilen i <em>Gökungen</em> är mycket närmare Läckbergs klassiska avtryck.</p>
<p>En rimlig förklaring skulle kunna vara att Engman, i sitt redaktörsarbete, lämnat stilistiska spår som plockas upp i analysen. Resultatet kanske pekar på ett mer intensivt samarbete, där den övervägande delen är Läckbergs, men där det finns tillräckligt mycket av Engman för att stilen ska skilja sig från Läckbergs vanliga romaner.<sup>9</sup> Detta är dock bara en gissning, en möjlig förklaring till varför stilen i <em>Fayes hämnd</em> bryter med den i <em>Fjällbacka-</em>serien.</p>
<blockquote><p>Författares stil förändras inte över en natt”, förklarar Kestemont.</p></blockquote>
<p>Mer långtgående slutsatser kan man däremot dra av resultaten från <em>Kvinnor utan nåd </em>och <em>Gå i fängelse</em>. Den sammanlagda slutsatsen från dataanalysen talar starkt för spökskrivarteorin. För <em>Kvinnor utan nåd </em>pekas Pascal Engman ut som den mest sannolika författaren av de åtta som programmet har analyserat. För <em>Gå i fängelse</em> hittas ingen bra matchning, men analysen talar tydligt för att stilen varken är Läckbergs eller, för den delen, Engmans. Även resultatet i JGAAP pekar alltså på en tredje part, det vill säga ytterligare en spökskrivare.</p>
<p>Jag stämmer av resultaten med <strong>Mike Kestemont</strong>, litteraturprofessor vid universitetet i Antwerpen och en av forskarna bakom Stylo.</p>
<p>– Såvitt jag kan se pekar <em>alla </em>resultat i analysen i samma riktning, vilket är viktigt, säger Mike Kestemont.</p>
<p>Han säger att sådana analyser såklart inte kan ”bevisa” någonting:</p>
<p>– Men man kan säga att dina resultat är <em>mer kompatibla</em> med spökskrivar-teorin än den nuvarande synen på vem som har skrivit dessa böcker.</p>
<p>Jag frågar också Kestemont huruvida det är möjligt att stiländringen från <em>Fjällbacka-</em>serien till kortromanerna kan förklaras av slump, och att Camilla Läckberg ändrade stil bara för dessa två romaner. ”Författares stil förändras inte över en natt”, förklarar Kestemont. ”Om det inte finns en uppenbar händelse i författarens liv som skulle kunna förklara detta.”</p>
<h2>Vill inte bemöta</h2>
<p><span style="font-weight: 400;">Jag kontaktar nu Camilla Läckberg via </span>PR-bolaget Assefa Communication i Stockholm som sköter hennes presskontakter. Efter ett dygn kommer svar i form av ett SMS från Läckbergs pressansvariga <strong>Paulina L. Bånge</strong>. Hon skriver:</p>
<p>– Jag har på nära håll fått ta del av hur hårt Camilla Läckberg jobbar med sina böcker. Dina anklagelser är inte något jag tänker bevärdiga med ett svar. 35 miljoner sålda böcker talar för sig själva, meddelar Bånge.</p>
<p><span style="font-weight: 400;">Ebba Östberg, publicistisk chef på Forum förlag, mejlar att det jag ”insinuerar är en allvarlig anklagelse”:</span></p>
<p><span style="font-weight: 400;"> – </span><span style="font-weight: 400;">Stilometri är tyvärr inte en metod jag är bekant med, så det blir svårt för mig att kommentera. Däremot kan jag gladeligen säga att en av Camilla Läckbergs många styrkor är att ständigt förnya sig och testa nya grepp och stilar, något vi som hennes förlag alltid satt stort värde på. Det har också bidragit till hennes näst intill unika position i den svenska och internationella deckarvärlden. </span></p>
<p>I ett föregående mejl skriver hon att Forum har arbetat med Camilla Läckberg i snart tjugo år: Ett samarbete som ”präglats av både förtrolighet, lust och professionalitet”.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="108475">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1,  Ben Blatt, <em>Nabokov’s Favorite Word is Mauve</em> (Simon and Schuster, 2017), 1-6, 59-62.</p>
<p>2, Ben Blatt,<em> Nabokov’s Favorite Word is Mauve</em>, 60.</p>
<p>3, <a href="https://securityaffairs.com/11652/cyber-crime/stylometric-analysis-to-track-anonymous-users-in-the-underground.html">https://securityaffairs.com/11652/cyber-crime/stylometric-analysis-to-track-anonymous-users-in-the-underground.html</a></p>
<p>4, <a href="https://computationalstylistics.github.io/projects/elena-ferrante/">https://computationalstylistics.github.io/projects/elena-ferrante/</a></p>
<p>5, För en tillgänglig sammanfattning för den som vill veta mer, läs: <a href="https://environmentalcomputing.net/graphics/multivariate-vis/mds/#:~:text=MDS%20arranges%20the%20points%20on,space%20to%20arrange%20the%20points">https://environmentalcomputing.net/graphics/multivariate-vis/mds/#:~:text=MDS%20arranges%20the%20points%20on,space%20to%20arrange%20the%20points</a>.</p>
<p>6, <a href="https://www.forum.se/nyheter/de-prisas-pa-arets-guldboksgala/"> https://www.forum.se/nyheter/de-prisas-pa-arets-guldboksgala/</a>. Dessa två kortromaner publicerades samlade i en tryckt pappersutgåva men släpptes som separata titlar som e-bok och ljudbok.</p>
<p>7, <a href="https://www.scientificamerican.com/article/how-a-computer-program-helped-show-jk-rowling-write-a-cuckoos-calling/">https://www.scientificamerican.com/article/how-a-computer-program-helped-show-jk-rowling-write-a-cuckoos-calling/</a></p>
<p>8, Tretton böcker av Camilla Läckberg (varav två är skrivna tillsammans med <strong>Henrik Fexeus</strong>): <em>Änglamakerskan, Fyrvaktaren, Gökungen, Häxan, Isprinsessan, Lejontämjaren, Olycksfågeln, Predikanten, Sjöjungfrun, Tyskungen, Stenhuggaren, Box </em>(med Henrik Fexeus), <em>Kult</em> (med Henrik Fexeus). Fem böcker av David Lagercrantz: <em>Det som inte dödar oss, Hon som måste dö, Mannen som sökte sin skugga, Memoria, Obscuritas</em>. Tre böcker av Liza Marklund: <em>Sprängaren, Prime time, Studio sex. </em>Tre böcker av Denise Rudberg: <em>Bara tre kan leka så, Ett litet snedsprång, Två gånger är en vana. </em>Fyra böcker av Sofie Sarenbrant: <em>Andra andningen, Parasiten, Själsfränden, Vila i frid. </em>Tre böcker av Stieg Larsson: <em>Män som hatar kvinnor, Luftslottet som sprängdes, Flickan som lekte med elden. </em>Tre böcker av Lars Kepler: <em>Eldvittnet, Spegelmannen, Spindeln. </em>Sex böcker av Pascal Engman: <em>Änkorna, Eldslandet, Kokain, Patrioterna, Råttkungen, X. </em></p>
<p>9, Jag utförde samma experiment i Stylo, som också har en funktion som bedömer <em>sannolikheten</em> att en viss författare har skrivit ett visst verk (mellan 0 och 1). Resultaten överensstämmer med analysen i JGAAP. För <em>Kvinnor utan nåd</em> tilldelades Pascal Engman 1, medan alla andra tilldelades 0. För <em>Gå i fängelse</em> tilldelades Lars Kepler 0.9, Sofie Sarenbrant 0.6, Karin Smirnoff 0,1. Både Engman och Läckberg tilldelades 0. För både <em>En bur av guld </em>och <em>Vingar av silver</em> fick Camilla Läckberg 1 och Pascal Engman 0.12 respektive 0.14. Detta är förenligt med en viss samverkan, men med Läckberg som står för merparten av skrivandet – men det är en rimlig förklaring till varför stilen i <em>Fayes hämd</em>-serien bryter i viss mån från Läckbergs stil i <em>Fjällbacka</em>-serien.</p>
<p>&nbsp;</p>
</div>
</div>
<div class="author-byline">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>
</div>
