Av Ola Wong | 30 oktober 2022
I korthet
Det mest dramatiska ögonblicket under den nu avslutade kongressen för Kinas kommunistparti (KKP) var när landets gamle ledare Hu Jintao blev förd ut ur Folkets stora sal av två manliga funktionärer. Officiellt sägs förklaringen vara Hus svaga hälsa, men man behöver inte vara konspirationsteoretiker för att se handlingen som en maktdemonstration. Hu Jintao lyftes symboliskt ut ur partihistorien.
<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-78683"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="78683" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfcGFydGlldF9zdHlyX2tpbmFzX2hpc3RvcmlhX2Zvcl9hdHRfa29udHJvbGxlcmFfZnJhbXRpZGVuLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvcGFydGlldC1zdHlyLWtpbmFzLWhpc3RvcmlhLWZvci1hdHQta29udHJvbGxlcmEtZnJhbXRpZGVuLm1wMw==">  <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%2Fpartiet-styr-kinas-historia-for-att-kontrollera-framtiden%2F&amp;t=Partiet+styr+Kinas+historia+f%C3%B6r+att+kontrollera+framtiden"    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=Partiet+styr+Kinas+historia+f%C3%B6r+att+kontrollera+framtiden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fpartiet-styr-kinas-historia-for-att-kontrollera-framtiden%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%2Fpartiet-styr-kinas-historia-for-att-kontrollera-framtiden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Partiet styr Kinas historia för att kontrollera framtiden&body=https://kvartal.se/artiklar/partiet-styr-kinas-historia-for-att-kontrollera-framtiden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/78683/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/78683/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/03/DSC_1185-1-scaled-e1646149873242.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/03/DSC_1185-1-scaled-e1646149873242.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/ola-wong/">Ola&nbsp;Wong</a> | 30 oktober 2022<div class="author-desc">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</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%2Fpartiet-styr-kinas-historia-for-att-kontrollera-framtiden%2F&amp;t=Partiet+styr+Kinas+historia+f%C3%B6r+att+kontrollera+framtiden"    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=Partiet+styr+Kinas+historia+f%C3%B6r+att+kontrollera+framtiden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fpartiet-styr-kinas-historia-for-att-kontrollera-framtiden%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%2Fpartiet-styr-kinas-historia-for-att-kontrollera-framtiden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Partiet styr Kinas historia för att kontrollera framtiden&body=https://kvartal.se/artiklar/partiet-styr-kinas-historia-for-att-kontrollera-framtiden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/78683/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/78683/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/partiet-styr-kinas-historia-for-att-kontrollera-framtiden/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/78683"    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-78683">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "78683"></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 ">Det mest dramatiska ögonblicket under den nu avslutade kongressen för Kinas kommunistparti (KKP) var när landets gamle ledare <strong>Hu Jintao</strong> blev förd ut ur Folkets stora sal av två manliga funktionärer. Officiellt sägs förklaringen vara Hus svaga hälsa, men man behöver inte vara konspirationsteoretiker för att se handlingen som en maktdemonstration. Hu Jintao lyftes symboliskt ut ur partihistorien.</p>
</div>
<div class="rest-of-article ">
<p>Landets historia var också ett av kongressens bärande teman. Kinas ledare <strong>Xi Jinping</strong> hade i sin stora rapport till kongressen utmålat Hu Jintaos tid vid makten (2002–2012) som en nedgångsperiod av svagt ledarskap då felaktiga tankemönster och <em>historisk nihilism </em>florerade. ”Nihilism” betyder i det här fallet att kritisera eller belysa något annan än Kommunistpartiets officiella historieskrivning.</p>
<p>Under Xis tio år vid makten har partihistorien skrivits om; ledarna under reformperiodens fyra årtionden, <strong>Deng Xiaoping</strong>, <strong>Jiang Zemin</strong> och <strong>Hu Jintao</strong>, bleknar alltmer bort. I stället finns två fixstjärnor kvar: <strong>Mao Zedong</strong> och Xi Jinping.</p>
<p>I den officiella berättelsen beskrivs Kinas historia som en rak utveckling från kejsartiden med Xi Jinpings era som enda möjliga resultat. Partiets blodiga historia, krossandet av det gamla samhället, de tiotals miljoner dödsoffren under Mao-tiden och de våldsamma svängningarna och maktkamperna som präglat rörelsen är förbjuden mark, <em>historisk nihilism.</em></p>
<h2>Yan’an är Kommunistpartiets Mekka</h2>
<p>I en tydlig signal vart Xi vill föra Kina tog han som första punkt efter kongressens avslutning med sig den nya politbyråns ständiga utskott på en <a href="https://english.news.cn/20221028/656bdc76d6d643df8ffa7b84a8e6989b/c.html?utm_source=substack&amp;utm_medium=email">pilgrimsresa till Yan’an </a> (uttalas jenn-ann), som var det legendariska basområdet för Maos kommunistgerilla under åren 1937–47.</p>
<p>Xi tog med sig de övriga partiledarna till platsen för den sjunde partikongressen 1945 och kallade Yan’an en ”helig plats för den kinesiska revolutionen”. Det är också en plats som representerar personkult, ideologisk likriktning och kamp. Det var på den kongressen som Mao blev partiets allsmäktige ledare. Detta skedde efter det att partiet klubbat igenom en resolution om KKP:s officiella historia.</p>
<p>Partiet slog då fast att Mao stod för allt som var korrekt i den revolutionära kampen, medan Maos motståndare, utlänningarna och nationalistregimen fick skulden för allt som hade gått fel. Mao hade då, efter åratal av bittra maktstrider, lyckats krossa och radera ut sina motståndare och tidigare partiledare. Historieresolutionen 1945 syftade till att skapa ett enat parti med en gemensam bild av historien. Likheterna med situationen för kongressen 2022 är uppenbara.</p>
<figure id="attachment_78703" aria-describedby="caption-attachment-78703" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-78703 size-full" src="https://kvartal.se/wp-content/uploads/2022/10/sdldvAfECNeeR8-nl.jpg" alt="" width="1024" height="683" data-wp-pid="78703" srcset="https://kvartal.se/wp-content/uploads/2022/10/sdldvAfECNeeR8-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2022/10/sdldvAfECNeeR8-nl-600x400.jpg 600w, https://kvartal.se/wp-content/uploads/2022/10/sdldvAfECNeeR8-nl-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2022/10/sdldvAfECNeeR8-nl-768x512.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-78703" class="wp-caption-text"><em>Xi Jinping talade på platsen där Mao ledde den sjunde partikongressen 1945 och uppmanade partiet att föra vidare kampandan från den tiden och stärka partiets förmåga. Foto: Yan Yan/AP/TT.</em></figcaption></figure>
<p>Det var i Yan’an som ”Mao Zedongs tänkande” blev partiets styrande ideologi och handlingsväg framåt. Idag är även ”Xi Jinpings tankar om socialism med kinesiska särdrag för en ny era” inskrivet i stadgarna på samma nivå. Xi och Mao är därmed de enda ledarna som anses ha ”tänkt” i partihistorien.</p>
<p>Det var under Yan’an-perioden som partiet utformade sina metoder av hjärntvätt och ideologisk likriktning. Indoktrineringen och metoden av kritik och självkritik upplyftes som en metod för att rensa människors själar och tvinga dem att acceptera sanningen, som den definieras av partiledningen för stunden.</p>
<blockquote><p>Att Xi åker till Yan’an med det budskapet borde vara en rejäl väckarklocka för världen.</p></blockquote>
<p>Det var från Yan’an som Kommunistpartiet förde krig och besegrade sina fiender.</p>
<p>När Xi nu åter besökte Yan’an den 27 oktober sade han att partiet måste föra vidare kampandan från Maos tid i Yan&#8217;an och stärka partiets tilltro till sin historia.</p>
<p>Flera gånger under talet upprepade Xi ordet kamp (se <a href="https://kvartal.se/artiklar/xi-jinpings-tredje-akt/">min artikel</a> från den 14/10 om politikens fraser). Han verkar se framför sig en långvarig period av både inre och yttre kamp. Även om Xi är medvetet otydlig med vad han avser för sorts strid så borde det vara en rejäl väckarklocka för världen att Xi åker till Yan’an med det budskapet.</p>
<h2>Historien är grunden för legitimitet</h2>
<p>”Den som styr historien, kontrollerar framtiden” står det i <strong>George Orwells</strong> dystopi <em>1984</em>, men Xi Jinping liksom partiet ser den mer som en manual.</p>
<p>Harvard-professorn <strong>Tony Saich </strong>skriver i sin massiva bok om Kommunistpartiets hundraåriga historia <em>From rebel to ruler </em>(Harvard University Press, 2021) att en avgörande förklaring till Maos framgångar var att han kunde presentera ett starkt narrativ om landets historia, som gav partiet legitimitet. Det var berättelsen om hur Kina förtrycktes av imperialister, jordägare och kapitalister, men räddades från undergången genom Kommunistpartiet. Detta ska rättfärdiga partiets ständiga maktmonopol. Xis narrativ följer samma tema, där det historiska uppdraget nu är att ena sig kring Xi för att förverkliga den stora nationella återfödelsen vid seklets mitt, då Kina ska vara världens mäktigaste nation räknat i styrka och inflytande.</p>
<p>I <a href="http://english.scio.gov.cn/20thcpccongress/2022-10/22/content_78480782.html">partiets stadgar</a> står det nu att KKP alltid har varit trofast mot sitt ursprungliga kall och mål att eftersträva lycka åt det kinesiska folket och den kinesiska nationens pånyttfödelse. Det är en uppenbar lögn. Partiets ursprungliga mål var det klasslösa samhället och sedan dess har man svängt många gånger. Därför måste lögnen upprepas många gånger så att den känns som en sanning. Partiets 96 miljoner medlemmar har nu fått krav på sig att studera den korrekta versionen av partiets historia.</p>
<p>Tilläggen i stadgarna som betonar partihistorien är enligt ledningen av stor vikt för att alla medlemmar ska kunna känna sig trygga med partiets förflutna och därmed ivrigt kunna delta i ”den nya kampen” för att bygga socialism i den nya eran under Xi.</p>
<p>Xi är liksom stora delar av partieliten besatt av tanken på Sovjetunionens fall. Slutsatsen man dragit i Peking är att orsaken till att KKP:s urmoder gick under var att ryssarna tappade tron på sin historiska uppgift. Skulden för det lägger de på Sovjetledaren <strong>Chrusjtjov</strong>, som kritiserade <strong>Stalin</strong> och dennes personkult i ett tal 1956. Den följande avstaliniseringen gjorde att det sovjetiska kommunistpartiet hamnade i ett andligt vakuum. När <strong>Gorbatjov</strong> sedan gjorde sina farliga frihetsreformer ”var ingen man nog” att försvara regimen, som Xi Jinping sade i ett internt tal som definierat hans ledartid.</p>
<p>Mao är Kommunistpartiets <strong>Lenin</strong> och <strong>Stalin</strong> i samma person. Om man börjar tvivla på Mao så ifrågasätter man både grunden för partiet och Xi.</p>
<h2>Censuren redigerar historiska arkiv</h2>
<p>I en kampanj inför partiets 100-årsfirande 2021 raderade censuren mer än två miljoner postningar som innehöll politiskt inkorrekta diskussioner om historien. Kineser som kritiserar historiska ”hjältar” har gripits.</p>
<p>Censuren har samtidigt kraftigt försämrat möjligheten för historiker att arbeta i Kina. Den direkta tillgången till kinesiska arkiv ströps så fort Xi Jinping kom till makten, mejlar <strong>Pär Cassel</strong> som är docent i modern kinesisk historia vid University of Michigan.</p>
<blockquote><p>En utställning om Xinjiang i Stockholm hade varit ett kraftfullt ställningstagande mot partiets minnesförstörare.</p></blockquote>
<p>En ny riskzon för forskarna är att partiet även har börjat redigera i online-arkiv. Exempelvis har den häftiga debatt som rådde i Kina på 1950-talet om huruvida landet borde ha ett oberoende rättsväsen censurerats bort. En amerikansk forskare, <a href="https://www.theatlantic.com/international/archive/2022/08/china-xi-jinping-biography-opacity/671195/"><strong>Glenn Tiffert,</strong> upptäckte detta</a> först efter att han jämfört nätarkivet med sina egna fysiska pappersexemplar, skriver The Atlantic. Partiet vill få det att framstå som historiskt otänkbart att Kina skulle kunna ha domstolar som inte var underkastade partiet.</p>
<p>Historien om demokratirörelsen och massakern vid Himmelska fridens torg 1989 är en annan händelse som partiet till stora delar har lyckats radera ur folkminnet, något som journalisten<strong> Louisa Lim</strong> skildrar i en bok med den talande titeln <a href="https://www.louisalim.com/peoples-republic-of-amnesia"><em>The People’s republic of amnesia</em> </a>(Folkets Minnesförlustsrepublik)</p>
<p>Kommunistpartiets arbete för att skriva om historien och radera kulturuttryck är också ett viktigt skäl till att museer och arkiv utanför Kina måste hålla fast i och bevara sina <em>fysiska </em>bibliotek och samlingar med föremål. Exempelvis har Etnografiska och Östasiatiska museet i Stockholm stora samlingar som visar Xinjiang och Tibet som det var före det kulturella folkmordet där. En utställning om Xinjiang som området var innan Kommunistpartiet kom dit hade varit ett kraftfullt ställningstagande mot partiets minnesförstörare.</p>
<p>Den negativa censuren, där partiet trycker ner och raderar historiska fakta, är dock bara en mindre del av partiets historiebruk. Den största energin ägnas åt att indoktrinera folket i den korrekta historieskrivningen. Det görs genom skolan, tv och filmer, turism till revolutionära minnesorter och så vidare. Målet är att skapa ett chauvinistiskt folk som reagerar ilsket och känner sin identitet hotad när den officiella historieskrivningen ifrågasätts.</p>
<p>Den officiella sanningen präntas in i folkets hjärnor genom ett oavbrutet och totalt samhällsgenomsyrande tjatande, i brist på bättre ord.</p>
<p><img decoding="async" class="wp-image-78697 size-full" src="https://kvartal.se/wp-content/uploads/2022/10/9789100196899.jpg" alt="" width="280" height="414" data-wp-pid="78697" srcset="https://kvartal.se/wp-content/uploads/2022/10/9789100196899.jpg 280w, https://kvartal.se/wp-content/uploads/2022/10/9789100196899-203x300.jpg 203w" sizes="(max-width: 280px) 100vw, 280px" /></p>
<h2>Ai Weiweis kamp om sanningen</h2>
<p>Går det ens att göra motstånd mot en sådan väldig apparat? Den kinesiske konstnären <strong>Ai Weiweis</strong> memoarer <em>1000 år av glädje och sorg </em>(Albert Bonniers förlag, 2022, översättare <strong>Anna Gustafsson Chen</strong>)  beskriver på ett strålande sätt glädjen av, men också det höga priset, för att ta striden om sanningen. I boken beskriver Ai Weiwei hundra år av Kinas historia, genom sitt eget och sin far <strong>Ai Qings </strong>liv. Fadern var en uppburen socialistisk poet som likt andra idealistiska kinesiska intellektuella sökte sig till Maos gerillabas i Yan&#8217;an. Där blir han först väl mottagen och sedan nerbruten av den kommunistiska sekten.</p>
<p>Det var i Yan&#8217;an som Mao höll sitt långa tal om kulturarbetarnas roll i det nya Kina, som sedan dess i långa perioder legat som en död hand över kulturlivet. Det kan kokas ner till två meningar. Det finns ingen konst för konstens egens skull. All konst måste tjäna politikens syfte.</p>
<p>Ai Qing blev till slut själv stämplad som högeravvikare. Han var en av 550 000 intellektuella som skickades ut i inre exil för ”omskolning genom arbete”. När den stämpeln lyftes 20 år senare var bara 100 000 fortfarande vid liv, och vid det laget hade allt oliktänkande i princip utrotats i Kina. Ai Weiwei skildrar hur han växte upp med pappan i en jordkula. En av förvisningsplatserna beskriver han som befolkad av människor vars ”plågsamma erfarenheter hade lärt dem att minne och identitet var farliga saker. Staten var en maskin som sög i sig minnet och blekte det vitt”.</p>
<blockquote><p>Även om Kina blir alltmer mäktigt sprider dess moraliska förfall bara oro och osäkerhet i världen, skriver Ai Weiwei.</p></blockquote>
<p>Under kulturrevolutionen brände pappan upp familjens böcker. Likt många andra kineser gjorde han det för att undvika ytterligare politiska problem. Ai Weiwei minns det som ett livsavgörande ögonblick när han stod vid bålet och rev ut blad efter blad ”som likt drunknande spöken vred sig i hettan och svaldes i lågorna”. Men i det ögonblicket böckerna förvandlades till aska kände han det som om han blev besatt av en underlig kraft, som sedan har följt honom genom livet: ”Ett ställningstagande för rim och reson, en känsla för skönhet och viljan att göra motstånd.”</p>
<p>I vuxen ålder utnyttjar Ai Weiwei Kinas öppning mot omvärlden efter Maos död och åker till New York. Han återvänder och blir en av världens mest kända konstnärer, men hans aktivism leder till alltmer problem. När tusentals barn begravs under fuskbyggda skolor i samband med jordbävningen i Sichuan 2008 startar Ai Weiwei en medborgarundersökning. I en trotsig programförklaring skriver han: ”Vi avvisar minnesförlusten, avvisar lögnerna” och avslutar med orden ”Dina handlingar är din värld”. Han inser att i någon mening är det en bräcklig regim han står inför och att han är tvungen att agera, att avslöja dess ondska. Han dokumenterar namnen på 5 196 omkomna skolbarn och gör hundratals intervjuer med sörjande föräldrar. Men partiet slår tillbaka på sitt vanliga sätt. ”Det som i slutändan chockade mig mest, förutom att så många barn avled så tragiskt, var att folk med tiden blev alltmer ointresserade av det hela – de övergav uppgiften, glömde saken, tystnade – som om katastrofen inte hade något med dem att göra”.</p>
<p>Ai Weiwei lever idag i landsflykt i Europa. Han känner hur han genom att lämna Kina förlorat en känsla av tillhörighet och fast grund, och nu driver som andmat med strömmen. Men Kina befinner också sig i samma dilemma, eftersom landet förkastar sitt minne och vägrar att på ett uppriktigt sätt ta itu med att bygga ett hälsosamt samhälle och etablera ett legitimt styrelseskick. Även om Kina blir alltmer mäktigt sprider dess moraliska förfall bara oro och osäkerhet i världen, skriver Ai Weiwei. Xi Jinpings handlingar motsäger inte den dystra profetian.</p>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
