Därför misslyckades revolten i Iran

<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-109091"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="109091" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC8xLWpyLWFobWVkaS1kYXJmb3ItbWlzc2x5Y2thZGVzLXJldm9sdGVuLWktaXJhbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvanItYWhtZWRpLWRhcmZvci1taXNzbHlja2FkZXMtcmV2b2x0ZW4taS1pcmFuLm1wMw==">  <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/idris-ahmedi/">Idris&nbsp;Ahmedi</a> | 3 oktober 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%2Fdarfor-misslyckades-revolten-i-iran%2F&amp;t=D%C3%A4rf%C3%B6r+misslyckades+revolten+i+Iran"    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=D%C3%A4rf%C3%B6r+misslyckades+revolten+i+Iran+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdarfor-misslyckades-revolten-i-iran%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%2Fdarfor-misslyckades-revolten-i-iran%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Därför misslyckades revolten i Iran&body=https://kvartal.se/artiklar/darfor-misslyckades-revolten-i-iran/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/109091/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/109091/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdarfor-misslyckades-revolten-i-iran%2F&amp;t=D%C3%A4rf%C3%B6r+misslyckades+revolten+i+Iran"    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=D%C3%A4rf%C3%B6r+misslyckades+revolten+i+Iran+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdarfor-misslyckades-revolten-i-iran%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%2Fdarfor-misslyckades-revolten-i-iran%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Därför misslyckades revolten i Iran&body=https://kvartal.se/artiklar/darfor-misslyckades-revolten-i-iran/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/109091/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/109091/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/darfor-misslyckades-revolten-i-iran/?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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/109091"    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-109091">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "109091"></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 ">Fjolårets folkliga protester i Iran och den islamiska republikens repression visar att landets politiska system har nått vägs ände. Regimen i Iran har visserligen lyckats kväsa proteströrelse efter proteströrelse i tre decennier, men kan inte uppnå stabilitet genom repression. Samtidigt är Irans dåligt organiserade demokratirörelse likt Sisyfos dömd till samma misslyckande.</p>
</div>
<div class="rest-of-article ">
<p>Folkliga protester i Iran har kommit att anta tre utmärkande drag. För det första har omfattande protester – vilka i stabila länder tillhör ovanligheterna – blivit vanliga. Därtill har de kommit tätare. Vidare har demonstranternas politiska krav blivit alltmer radikala över tid, från krav på bättre levnadsvillkor och reformer till regimförändring.</p>
<h2>Skoningslös repression</h2>
<p>Studenter protesterade mot islamiska republiken år 1999 med krav på pressfrihet och politiska reformer, men möttes av skoningslös repression.<sup>1</sup> Protester i mindre omfattning och varaktighet har inträffat med jämna mellanrum och i regel kretsat kring socioekonomiska spörsmål.<sup>2</sup></p>
<p>År 2009, i kölvattnet av ett kontroversiellt presidentval, inträffade de största folkliga protesterna i islamiska republikens historia. Regimen anklagades för ”valfusk”. Den ”gröna” rörelse som organiserade protesterna var politiskt oförmögen att mobilisera medborgare över hela landet. Ty rörelsen leddes av regimtrogna politiker som den tidigare premiärministern <strong>Mir-Hossein Mousavi</strong> och hade modesta krav: rättvisa – dock inte nödvändigtvis fria – val inom islamiska republiken. Den hade huvudsakligen medelklassens stöd i huvudstaden och de större städerna. ”Var är min röst?” blev emblematisk för denna proteströrelse. Sedermera radikaliserades kraven. ”Död åt diktatorn”, ett slagord riktat mot högste ledaren <strong>Ali Khamenei</strong>, blev vanligare i protesternas slutskede. Ledarna för gröna rörelsen, trots att de placerades i husarrest, fortsatte att kräva förändring <em>inom</em> snarare än <em>av</em> islamiska republiken.<sup>3</sup></p>
<p>Folkliga protester inträffade åter i slutet av 2017 och början av 2018. Det var huvudsakligen fattiga iranier som deltog. Regimen slog brutalt ner även den protestvågen. Protesterna indikerade dock tydligare än någonsin att kravet på regimförändring vunnit fotfäste, då demonstranterna skanderade slagord som hade udden riktade mot islamiska republiken som sådan.<sup>4</sup></p>
<h2>Framväxande solidaritet mellan olika grupper</h2>
<p>Protesterna i fjol saknar motstycke i islamiska republikens historia. Det är inte enbart protesternas omfattning – vilka inträffade i landets samtliga 31 provinser – eller det resoluta kravet på regimförändring som är unikt.<sup>5</sup> Slagordet ”kvinna, liv, frihet”, som ursprungligen är kurdiskt och skanderades i samband med begravningsprocessionen för <strong>Jina Amini</strong>, förenade olika folk- och samhällsgrupper i Iran.<sup>6</sup> Även solidaritetsyttringar med kurderna blev kännetecknande för denna proteströrelse.<sup>7</sup></p>
<blockquote><p>Av landets 85 miljoner invånare är 70 procent under 30 år.</p></blockquote>
<p>Studenter, arbetare, medellösa, minoriteter, kvinnor och medelklassen har alla de senaste decennierna protesterat mot regimen, men utan solidaritet eller koordination sinsemellan. Detta slags atomisering av det iranska samhället har gynnat regimen och underlättat för dess våldsapparat att slå ner proteströrelse efter proteströrelse. Mot den bakgrunden utgör den senaste protestvågen ett trendbrott.</p>
<p>De demografiska förändringarna är en relevant grundorsak när det gäller Iran, jämte de ekonomiska och politiska förhållanden som framhålls i samhällsvetenskaplig forskning om revolution. Befolkningen har fördubblats sedan revolutionen 1979. Av landets 85 miljoner invånare är 70 procent under 30 år.<sup>8</sup> Föga överraskande hade de unga en framträdande roll i fjolårets uppror.<sup>9</sup></p>
<figure id="attachment_109176" aria-describedby="caption-attachment-109176" style="width: 2560px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-109176 size-full" src="https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-scaled.jpg" alt="" width="2560" height="1703" data-wp-pid="109176" srcset="https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-1536x1022.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-2048x1362.jpg 2048w, https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-600x399.jpg 600w, https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2023/10/sdlwAahlxuWH_s-768x511.jpg 768w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-109176" class="wp-caption-text">Demonstration i Tyskland, hösten 2022. Foto: Christophe Gateau /TT</figcaption></figure>
<p>Ytterligare en orsak till protester är exkludering och systematisk diskriminering av delar av befolkningen. Kvinnor är exkluderade från den politiska makten och diskrimineras systematiskt i islamiska republiken. Diskrimineringen av dem är religiöst sanktionerad och har institutionaliserats genom existerande islamisk lagstiftning.<sup>10</sup> Nationella minoriteter som azerer, kurder, baloucher, araber och turkmener har historiskt varit exkluderade och utsätts för systematiskt förtryck.<sup>11</sup> Islamiska republiken marginaliserar även regimtrogna individer och fraktioner. Detta har breddat motståndet mot regimen hos alltfler samhällsgrupper.<sup>12</sup></p>
<p>Även ekonomiska förhållanden är viktiga att beakta i det perspektivet. Fattigdomen och ojämlikheten i Iran breder ut sig. Det iranska inrikesministeriets egna siffror visar att 60 procent av landets befolkning lever under den relativa fattigdomsgränsen. Inrikesministeriet uppskattar även att 20 till 30 miljoner av dem lever i absolut fattigdom.<sup>13</sup></p>
<h2>Från val utan demokrati till dubbelt riggade val</h2>
<p>Vidare kan förändringar i det politiska systemet utgöra en grundorsak till revolution. Islamiska republiken är till sin natur en personalistisk regim, då avgörande formell och informell makt är samlad hos den högste ledaren. Återkommande val och till synes folkvalda institutioner har skylt över detta faktum. Det finns därför anledning att åberopa den platonska distinktionen mellan sken och verklighet när det kommer till islamiska republiken. Maktkoncentration och auktoritärt styre utgör dess verkliga natur medan valen och de folkvalda institutionerna är skenbara.<sup>14</sup></p>
<p>Khamenei, sedan han utnämndes till högste ledare, har koncentrerat makt i sina egna händer och marginaliserat meningsmotståndare. Genom sitt agerande har han bidragit till att regimens personalistiska natur blivit uppenbar för alltfler människor i Iran. Khamenei har gått så långt som att arrangera dubbelt riggade val för att åstadkomma åsiktskonformism inom regimen.</p>
<p>Valen i islamiska republiken är inte fria och i en fundamental mening riggade till regimtrogna kandidaters fördel. Omvalet av <strong>Mahmoud Ahmadinejad</strong> 2009 och valet av <strong>Ibrahim Raisi</strong> 2021 – liksom massdiskvalificering av kandidater till valen för den annars maktlösa islamiska rådslagsförsamlingen – visar med tydlighet att Khamenei bland otaliga regimtrogna kandidater särbehandlar dem som står honom personligen nära eller som bedöms ställa sig i ledet. När Ahmadinejad sökte skapa sin egen maktbas föll han i onåd hos Khamenei och blev sedermera hindrad av väktarrådet – en icke-vald institution vars medlemmar direkt och indirekt utses av högste ledaren och därmed kontrolleras av honom – från att ställa upp i presidentvalet 2017. Den tidigare presidenten <strong>Ali Akbar Hashemi Rafsanjani</strong>, tillika en av islamiska republikens viktigaste förgrundsgestalter, gick samma öde till mötes.<sup>15</sup></p>
<p>En statsvetenskaplig studie ger vid handen att andelen presidentkandidater som väktarrådet godkänt mellan åren 1980 och 2013 minskade från 9 till mindre än 1 procent.<sup>16</sup> Att Khamenei med hjälp av väktarrådet arrangerar dubbelt riggade val visar att regimen utvecklats i en riktning där alltfler i de egna leden blir marginaliserade, särskilt de som utger sig för att vara reformister.</p>
<blockquote><p>Kan det ske en regimförändring i Iran? Tre decennier av återkommande protester i landet manar inte till någon större optimism.</p></blockquote>
<p>”Reformisterna” är regimbevarande snarare än regimförändrande. De har utgjort en synnerligen viktig politisk resurs för islamiska republiken – såväl hemmavid som internationellt. Genom ospecificerade löften om reformer kunde de mobilisera stora väljargrupper i val efter val alltsedan mitten av 1990-talet och lyckades i allt väsentligt förvandla en diktatur som arrangerar val till en vald diktatur, i vilken även västvärlden såg förändringspotential.</p>
<p>Marginaliseringen av reformisterna och de numera dubbelt riggade valen har underminerat regimens institutioner. Konsekvensen av detta är att regimens ställning i det iranska samhället blivit än mer försvagad. Det är föga överraskande att mer än 50 procent av de röstberättigade bojkottade det senaste presidentvalet i islamiska republiken – vilket är det lägsta valdeltagandet i presidentval sedan 1980 – men också varför en ung och otålig befolkning kräver regimförändring.<sup>17</sup></p>
<h2>Den kroniska konflikten med USA</h2>
<p>Till skillnad från en del andra regimer som uppstått ur revolution, och som med tiden blivit mer moderata eller anpassat sig till den externa säkerhetspolitiska miljön, har islamiska republiken gått i motsatt riktning.<sup>18</sup> Islamiska republiken har sedan 1979 haft konfliktfyllda relationer med Förenta staterna. Den ideologiskt motiverade fientligheten mot USA har föranlett amerikanska sanktioner mot landet, särskilt efter uppdagandet av islamiska regimens kärnprogram i början av millenniet.<sup>19</sup></p>
<p>Irans ekonomiska problem är emellertid strukturella och bottnar i en starkt intervenerande stat i förening med misskötsel, omfattande korruption inom statsapparaten samt islamiska revolutionsgardets överdimensionerade roll i ekonomin.<sup>20</sup> Amerikanska sanktioner har visserligen påverkat ekonomin. De har emellertid inte försatt Iran i ett revolutionärt tillstånd. Folkliga protester i Iran förekom även när sanktionerna, till följd av uppgörelsen om kärnprogrammet år 2015, hade varit hävda i drygt tre år. De folkliga protester som inträffade före och efter årsskiftet 2017/2018 indikerar att det även i frånvaro av amerikanska sanktioner existerar en jordmån för revolution.</p>
<p>Islamiska republiken har inte bara visat sig resistent mot reformer, den har blivit alltmer ideologiskt rigid och exkluderande. Anhopningen av problem som det teokratiska styret genererar har fört landet till randen av revolution.<sup>21</sup></p>
<h2>En resursstark och repressiv stat</h2>
<p>Kan det ske en regimförändring i Iran? Tre decennier av återkommande protester i landet manar inte till någon större optimism.</p>
<p>En möjlig förklaring till detta skulle kunna vara att islamiska republiken besitter omfattande repressiv förmåga samtidigt som iranska proteströrelser visat sig oförmögna att skapa breda och landsomfattande koalitioner.<sup>22</sup></p>
<p>Repressiv förmåga är emellertid inte hela förklaringen till islamiska republikens fortbestånd. Även shahens regim besatt en formidabel repressiv förmåga. Ändå föll den 1979. Shahens armé, som hade deltagit i repressionen av proteströrelsen i drygt ett år, ställde sig till slut neutral i konflikten mellan demonstranterna och staten. Samma sak inträffade i Tunisien 2011.<sup>23</sup></p>
<p>Auktoritära regimer upprätthålls i regel av tre pelare: ideologisk indoktrinering, <a href="https://sv.wikipedia.org/wiki/Kooptation">kooptering</a> av delar av befolkningen samt hot om eller bruk av repression.</p>
<p>Den ideologiska indoktrineringen i Iran har spelat ut sin roll. Som ideologisk överbyggnad har islamiska republiken i allt väsentligt redan fallit. Detta framgår inte bara av återkommande proteströrelser som med tiden radikaliserats och kräver regimförändring, utan även i att alltfler iranier vänt islam ryggen.<sup>24</sup> Om regimen hade varit säker på sin ställning i det iranska samhället hade den av allt att döma inte behövt rigga valen – än mindre dubbelt riggade val.</p>
<p>Iran är, trots dess ekonomiska problem, en resursstark stat och Islamiska republiken har koopterat delar av befolkningen. Den offentliga sektorn är överdimensionerad och ungefär hälften av landets hushåll försörjs av staten.<sup>25</sup> En stor del av befolkningen står i beroendeställning till islamiska republiken.</p>
<p>Islamiska revolutionsgardet, en väpnad styrka på 200 000 man, uppskattas kontrollera en ansenlig del av Irans ekonomi och har av <strong>Hassan Rohani</strong>, Irans förre president, beskrivits i termer av en parallell ”regering med vapen.”<sup>26</sup> Revolutionsgardets konglomerat inom byggsektorn, för att nämna ett exempel, har inte mindre än 135 000 anställda.<sup>27</sup></p>
<p>Basijmilisen, en ideologisk förtrupp som utgör världens största milis, uppskattas ha fem miljoner medlemmar.<sup>28</sup> Tillsammans med landets polisstyrkor, vilka uppskattas vara mellan 100 000 och 200 000, förfogar islamiska republiken över ansenliga väpnade och paramilitära styrkor som specifikt är ämnade för att slå ner uppror.<sup>29</sup></p>
<p>Revolutionsgardet skulle förlora sitt existensberättigande och sina ekonomiska privilegier vid ett eventuellt regimskifte. Likaså basijmilisen, vilket skapar incitament för dessa styrkor att säkerställa islamiska regimens överlevnad. Detta förklarar regimens politiska vilja att använda repression. Islamiska republiken har därför visat sig villig och kapabel att kväsa iranska proteströrelser.</p>
<h2>Ödesfrågan för Irans demokratirörelse</h2>
<p>Det är emellertid inte islamiska republikens formidabla repressiva förmåga i sig eller den politiska viljan att använda repression som förklarar varför den har överlevt i mer än fyra decennier. Ty frånvaron av en enig och rikstäckande opposition har kommit att utgöra en styrka för regimen.</p>
<p>Islamiska republiken har eliminerat all opposition och lönnmördat oppositionella över hela världen. Enligt en kartläggning av Iran Human Rights Documentation Center har islamiska republiken lönnmördat 162 oppositionella i Sverige, USA, Österrike, Frankrike och en rad andra länder.<sup>30</sup></p>
<p>Senare års proteströrelser saknar organisation och ledarskap i traditionell mening, medan oppositionella grupper i exil inte har förmått skapa någon trovärdig allians.<sup>31</sup></p>
<blockquote><p>Iranska monarkins fall liksom sovjetimperiets kollaps visar att auktoritära regimer är allt annat än oövervinnerliga.</p></blockquote>
<p>Visserligen förmådde den senaste proteströrelsen uppvisa en sällan skådad solidaritet mellan landets olika folkgrupper. Detta är ingen blygsam framgång, givet att islamiska regimen till sin natur är sekteristisk och har livnärt sig på att underblåsa fientlighet mellan olika folkgrupper i landet. Men proteströrelsen mäktade inte med att frambringa en koalition av det slag som kan mobilisera miljoner människor eller bana väg för avhopp inom de väpnade styrkorna – som i revolutionen mot shahen 1979 eller revolutionen i Tunisien 2011.<sup>32</sup></p>
<p>Trots att regimen har omfattande repressiv förmåga och har visat sig skoningslös, kan en bred koalition med förmåga att mobilisera miljoner människor över hela landet tippa maktbalansen till folkets favör. I likhet med andra korrupta och illegitima regimer är islamiska republikens styrka mer illusorisk än verklig, men fram till dess att den faller kommer illusionen om dess styrka att utgöra (den upplevda) verkligheten. Iranska monarkins fall liksom sovjetimperiets kollaps visar att auktoritära regimer är allt annat än oövervinnerliga.</p>
<p>Basijmilisen må ha många miljoner medlemmar. Medlemskap i denna milis är emellertid för många enda vägen till inkomst och tillgång till utbildning. I samband med repressionen av fjolårets protester uppdagades också ”tvivel och förvirring” bland revolutionsgardets medlemmar.<sup>33</sup> Koordinerade och landsomfattande protester kan skingra, nöta ut och demoralisera regimens repressiva styrkor. En landsomfattande koalition i Iran kan dessutom dra nytta av det faktum att islamiska republiken redan fallit som ideologiskt projekt.</p>
<p>I frånvaron av en sådan bred koalition kommer en situation av varken stabilitet eller revolution att bestå under överskådlig tid.<a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="109091">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li>”Student Protests Shake Iran’s Government”, New York Times, 1999-07-11.</li>
<li>Saeid Golkar, Protests and Regime Suppression in Post-Revolutionary Iran. The Washington Institute for Near East Policy, PN85, oktober 2020.</li>
<li>Misagh Parsa, Democracy in Iran: Why It Failed and How It Might Succeed (Cambridge, Mass: Harvard University Press, 2016), kap. 7.</li>
<li>Iran: A limited opposition movement and a chronic regime crisis. Al Jazeera Centre For Studies, Policy Brief, 2018-01-14.</li>
<li>”Protesters rally across Iran in third week of unrest over Amini’s death”, Reuters 2022-19-01.</li>
<li>Jina Amini misshandlades i moralpolisens häkte för att burit sin slöja på otillbörligt sätt. Hennes död blev gnistan till det folkliga upproret i Iran hösten 2022.</li>
<li>Parisa Hafezi &amp; Daren Butler, ”Putting Kurds in spotlight, Iran’s leaders try deflect national protest”, Reuters 2022-10-17.</li>
<li>Parisa Hafezi, ”Iran’s clerical leaders to grapple with deepening dissent in 2023”, Reuters 2022-12-23.</li>
<li>”Barnen som riskerar livet i protesterna i Iran”, Sveriges Radio 2022-10-18.</li>
<li>Beyond the Veil: Discrimination against Women in Iran. Ceasefire Centre For Civilian Rights, september 2019.</li>
<li>Alireza Asgharzadeh, Iran and the Challenge of Diversity: Islamic Fundamentalism, Aryanist Racism, and Democratic Struggles (New York: Palgrave Macmillan, 2007).</li>
<li>Misagh Parsa, Democracy in Iran, passim.</li>
<li>”Poverty Doubled In Iran In One Year – Welfare Ministry”, Iran International 2023-01-02. <a href="https://www.iranintl.com/en/202301025682">https://www.iranintl.com/en/202301025682</a> (hämtad 2023-05-02).</li>
<li>Idris Ahmedi &amp; Ali Abdelzadeh, ”Iran” i Carsten Anckar &amp; Thomas Denk (red.) Komparativ politik: Elva politiska system (Lund: Studentlitteratur, tredje upplagan 2022), s. 311 ff.</li>
<li>Ahmedi &amp; Abdelzadeh, ”Iran” s. 323 ff.</li>
<li>Luciano Zaccara, ”Elections and Authoritarianism in the Islamic Republic of Iran”, i Mahoud Hamad &amp; Khalil al-Anani (red.), Elections and Democratization in the Middle East: The Tenacious Search for Freedom, Justice, and Dignity (New York: Palgrave Macmillan, 2014).</li>
<li>Parisa Hafezi, ”Khamenei protege win election amid low turnout”, Reuters 2021-06-19.</li>
<li>Se Stephen Walt, Revolution and War (Ithaca: Cornell University Press, 1996), kap. 5.</li>
<li>”Timeline of U.S. Sanctions”, The Iran Primer, United States Institute of Peace. <a href="https://iranprimer.usip.org/resource/timeline-us-sanctions">https://iranprimer.usip.org/resource/timeline-us-sanctions</a> (hämtad 2023-05-05)</li>
<li>Parsa, Democracy in Iran, kap. 3-4; ”Iran’s economy plagued by structural problems”, The Guardian 2015-11-02.</li>
<li>Parsa, Democracy in Iran, kap. 9-10.</li>
<li>Jfr Zoltan Barany, How Armies Respond to Revolutions and Why (Princeton: Princeton University Press, 2016); Parsa, Democracy in Iran.</li>
<li>Zoltan Barany, How Armies Respond to Revolutions and Why, kap. 2, 5.</li>
<li>Ladan Boroumand, ”Iranians Turn Away from The Islamic Republic”, Journal of Democracy, Vol. 31, No. 1 (januari 2020); Hafezi, ”Khamenei protege win election amid low turnout””</li>
<li>Parsa, ”Iran’s Republic of Repression”, Journal of Democracy, Vol. 31, No. 3 (juli 2020), s. 62.</li>
<li>Thomas Erdbrink, ”In Iran, Rouhani begins 2nd term with signs he’s yielding to hard-liners”, The New York Times 2017-08-03.</li>
<li>Parsa, ”Iran’s Republic of Repression”, s. 62.</li>
<li>Saeid Golkar, “Iran’s Coercive Apparatus: Capacity and Desire,” Washington Institute for Near East Policy, PolicyWatch 2909, 2018-01-05.</li>
<li>Ibid.</li>
<li>”No safe haven: Iran’s global assassination campaign”, Iran Human Rights Documentation Center, 2009. <a href="https://iranhrdc.org/no-safe-haven-irans-global-assassination-campaign/">https://iranhrdc.org/no-safe-haven-irans-global-assassination-campaign/</a> (hämtad 2023-05-05).</li>
<li>”Iran exiled opposition figures in talks to unite against government”, Reuters 2023-02-10.</li>
<li>Zoltan Barany, How Armies Respond to Revolutions and Why, kap. 2, 5.</li>
<li>Melanie Swan, ”Hijab protests sow doubt and confusion among Iran’s revolutionary guards”, The Times 2023-02-10.</li>
</ol>
</div>
</div>
<div class="author-byline">Idris Ahmedi är lektor i statsvetenskap vid Karlstads universitet.
</div>
</div>
