I korthet
I juli publicerade ”Global network against food crises” rapporten Global report on food crises (GRFC 2022). Nätverket består av ett antal olika organisationer, inklusive FN:s livsmedelsprogram. Rapporten delar in livsmedelskriser i fem klasser efter svårighetsgrad utifrån den etablerade Integrated food security phase classification. Under 2021 uppskattades livsmedelssituationen ha varit ”katastrofal” för 570 000 människor i världen.
<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/fredrik-charpentier-ljungqvist/">Fredrik&nbsp;Charpentier Ljungqvist</a> | 15 september 2022<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%2Ffred-basta-vapnet-mot-hunger%2F&amp;t=Fred+%C3%A4r+b%C3%A4sta+vapnet+mot+hunger"    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=Fred+%C3%A4r+b%C3%A4sta+vapnet+mot+hunger+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffred-basta-vapnet-mot-hunger%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%2Ffred-basta-vapnet-mot-hunger%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Fred är bästa vapnet mot hunger&body=https://kvartal.se/artiklar/fred-basta-vapnet-mot-hunger/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/74234/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/74234/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 author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </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%2Ffred-basta-vapnet-mot-hunger%2F&amp;t=Fred+%C3%A4r+b%C3%A4sta+vapnet+mot+hunger"    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=Fred+%C3%A4r+b%C3%A4sta+vapnet+mot+hunger+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffred-basta-vapnet-mot-hunger%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%2Ffred-basta-vapnet-mot-hunger%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Fred är bästa vapnet mot hunger&body=https://kvartal.se/artiklar/fred-basta-vapnet-mot-hunger/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/74234/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/74234/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 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 13 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/74234"    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-74234">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "74234"></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 ">I juli publicerade ”Global network against food crises” rapporten <em>Global report on food crises</em> (GRFC 2022). Nätverket består av ett antal olika organisationer, inklusive FN:s livsmedelsprogram. Rapporten delar in livsmedelskriser i fem klasser efter svårighetsgrad utifrån den etablerade <em>Integrated food security phase classification</em>. Under 2021 uppskattades livsmedelssituationen ha varit ”katastrofal” för 570 000 människor i världen.</p>
</div>
<div class="rest-of-article ">
<p>Med mer vardagligt språkbruk handlar det om akut och livshotande svält. För ytterligare drygt 39 miljoner människor utgjorde livsmedelssituationen en ”nödsituation”. Därtill var livsmedelssituationen ”krisartad” för runt 133 miljoner människor och ”stressad” för nästan en kvarts miljard människor. Omkring 40 miljoner fler människor i världen levde under en ”krisartad” eller värre livsmedelssituation 2021 än 2020.</p>
<figure id="attachment_74246" aria-describedby="caption-attachment-74246" style="width: 962px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-74246 size-full" src="https://kvartal.se/wp-content/uploads/2022/09/tabell-1.png" alt="" width="962" height="389" data-wp-pid="74246" srcset="https://kvartal.se/wp-content/uploads/2022/09/tabell-1.png 962w, https://kvartal.se/wp-content/uploads/2022/09/tabell-1-600x243.png 600w, https://kvartal.se/wp-content/uploads/2022/09/tabell-1-300x121.png 300w, https://kvartal.se/wp-content/uploads/2022/09/tabell-1-768x311.png 768w" sizes="(max-width: 962px) 100vw, 962px" /><figcaption id="caption-attachment-74246" class="wp-caption-text">Antal människor som upplever en ”krisartad”, eller värre, livsmedelssituationen år 2018–2021 uppdelat efter den viktigaste orsaken till hungersnöden. De negativa effekterna av covid-19-relaterade restriktioner som orsak till en ekonomisk chock (stor nog för att framkalla hunger) framträder ganska tydligt. Notera också att någon ökning inte skett av antalet som drabbas av hunger på grund av ”extremväder”.</figcaption></figure>
<p>Säkra belägg finns det för en ”katastrofal” livsmedelssituation – alltså akut svält – i Tigray-regionen i Etiopien där inbördeskrig utbrutit, och där över 400 000 människor uppskattades ha svultit mellan juli och september förra året. Dessutom svalt mellan april och juli över 100 000 människor i Sydsudan och under våren knappt 50 000 i inbördeskrigets Jemen. Plus runt 14 000 människor i Grand Sud-området på Madagaskar (se figur 1).</p>
<figure id="attachment_74254" aria-describedby="caption-attachment-74254" style="width: 1313px" class="wp-caption alignnone"><img decoding="async" class="wp-image-74254 size-full" src="https://kvartal.se/wp-content/uploads/2022/09/1.png" alt="" width="1313" height="699" data-wp-pid="74254" srcset="https://kvartal.se/wp-content/uploads/2022/09/1.png 1313w, https://kvartal.se/wp-content/uploads/2022/09/1-600x319.png 600w, https://kvartal.se/wp-content/uploads/2022/09/1-300x160.png 300w, https://kvartal.se/wp-content/uploads/2022/09/1-768x409.png 768w" sizes="(max-width: 1313px) 100vw, 1313px" /><figcaption id="caption-attachment-74254" class="wp-caption-text">Figur 1: Karta över förekomsten av en ”krisartad”, eller värre, livsmedelssituation på nationell nivå under år 2021. De fyra länder där akut svält förekom 2021 (Sydsudan, Jemen, Madagaskar och Etiopien) är särskilt utmärkta liksom var det förekom en väpnad konflikt på ett lands territorium. Information om livsmedelssituationen, liksom den över akut svält, härrör från GRFC-rapporten. Data över förekomsten av väpnade konflikten härrör från <em>Stockholm International Peace Research Institute Yearbook 2022</em>. Observera att väpnade konflikter innefattar storskaliga stridigheter mellan, och mot, drogsyndikat och andra kriminella grupperingar med militär kapacitet.</figcaption></figure>
<p>I alla dessa svältområden är det många fler som hungrar än som akut svälter. Omfattningen av dödligheten i svält eller av långvarig undernäring i världen under 2021 är svår att ens uppskatta. Den som, såsom undertecknad, studerar hungersnöd under historien är bekant med hur svårt det är att säkert fastslå <em>när</em> och <em>var</em> svält verkligen ägde rum och <em>hur</em> hög dödlighet den förde med sig.</p>
<p>En anledning till det är att dödligheten under hungersnöd främst orsakas av vanliga infektionssjukdomar som blir mycket dödligare, och även mer lättspridda, när stora delar befolkningen har ett kraftigt nedsatt immunförsvar på grund av långvarig näringsbrist.</p>
<h2>Livsmedelskriser på flera håll i världen</h2>
<p>För runt en miljon människor i Pakistan respektive Haiti var livsmedelsförsörjningen under 2021 en ”nödsituation”. Verklig svält drabbade dock inte dessa två länder. Oroväckande är ökningen av antalet människor i Pakistan som upplevde en ”krisartad” livsmedelssituation. En ”stressad” livsmedelssituation för stora delar av befolkningen är geografiskt betydligt mer utbredd än där den är ”krisartad”. I följande länder upplevde över 40 procent av befolkningen en ”stressad” livsmedelssituation förra året: Afghanistan, Burundi, Etiopien, Guatemala, Kongo, Madagaskar, Moçambique, Nigeria och Sudan.</p>
<blockquote><p>Pandemin och kriget i Ukraina har gjort att hungerbekämpning har nedprioriterats.</p></blockquote>
<p>En möjlig bidragande orsak till den svåra situationen är att humanitärt bistånd från en rad olika hjälporganisationer, i form av livsmedelshjälp, minskat kraftigt från och med 2020 jämfört med föregående år. År 2020 – siffror saknas ännu för 2021 – spenderades runt åtta miljarder dollar på humanitärt bistånd i form av livsmedelshjälp, jämfört med nästan 11 miljarder dollar under toppåren 2017 och 2018 för sådant bistånd. Pandemin och kriget i Ukraina har gjort att hungerbekämpning har nedprioriterats.</p>
<p>GRFC-rapporten lyfter särskilt fram den svåra situationen i flyktingläger i den fattigaste delen av världen. Det är där, och inte i rikare delar av världen, som merparten av alla flyktingar hamnar. På många håll förhindras eller begränsas flyktingarnas möjlighet till förvärvsarbete eller att driva någon typ av näringsverksamhet för sin försörjning. Samtidigt är det ekonomiska understöd eller de matransoner som de erhåller ofta otillräcklig.</p>
<p>För att överleva tvingas inte sällan flyktingar att sälja de (ofta små) tillgångar de har – och därmed pressas djupare ned i extrem fattigdom – eller, ibland, engagera sig i mer eller mindre olagliga verksamheter. I dagsläget är biståndet som når flyktingläger i världens fattigaste delar (framför allt Afrika), varav många officiellt inte ens existerar, otillräckligt för att avhjälpa den humanitära kris som pågår där. Av världens uppskattningsvis 51 miljoner internflyktingar, alltså flyktingar inom det egna landet, befann sig närmare 45 miljoner i just länder eller regioner som lider av svår livsmedelskris eller svält.</p>
<h2>Dyster prognos för 2022</h2>
<p>Det är svårt att följa utvecklingen av hungersnöd i världen eftersom hungern är koncentrerad till världens minst utvecklade och mest konfliktdrabbade delar. Prognosen för 2022, författad när halva året redan förflutit, är en dyster läsning. Vi kan snarare förvänta oss en svag ökning av antalet hungrande i världen än en förbättring.</p>
<p>Pandemin och sedan omvärldens fokus på Rysslands invasion av Ukraina har fått bekämpningen av hunger i Afrika att snarast glömmas bort. Den långvariga och svåra torkan på Afrikas horn försvårar situationen.</p>
<p>En annan anledning är att kriget drivit fram högre livsmedelspriser. Omfattande hungersnöd är nu bland annat att vänta även i Nigeria. Livsmedelskrisen i inbördeskrigens Jemen och Sydsudan förväntas fortgå som tidigare liksom den i Afghanistan och Kongo. Under år 2022 som helhet förväntas livsmedelssituationen vara ”krisartad”, eller värre, för 63 procent av befolkningen i Sydsudan, för 60 procent i Jemen, för 55 procent i Afghanistan, för 48 procent i Centralafrikanska republiken, för 45 procent i Haiti och för 38 procent i Somalia.</p>
<p>I Somalia ser nu situationen ut att falla ut betydligt värre än prognosen, främst på grund av den ihållande svåra torkan och omfattande angrepp på grödorna av gräshoppor. Detsamma gäller andra länder på Afrikas horn.</p>
<h2>I ett större sammanhang</h2>
<p>GRFC-rapporten bör delvis läsas som ett politiskt dokument. Ett historiskt perspektiv – även ett kort sådant – saknas i den. När FN:s generalsekreterare <strong>António Guterres</strong> i förordet skriver att vi ”<em>are facing hunger on an unprecedented scale</em>” är det uppenbart att perspektivet är mycket kort. Visserligen har extrem fattigdom och undernäring ökat i världen sedan ett par år tillbaka. Men enligt FN:s egen statistik har andelen av världens befolkning som är kroniskt undernärd minskat från runt 15 procent i början av 2000-talet till runt 10 procent i skrivande stund. Nedgången är ännu mer märkbar om vi går tillbaka till 1900-talet. Omkring 1970 var andelen kroniskt undernärda i världen runt 30 procent och ännu 1990 runt 20 procent.</p>
<p>Historiskt sett, före mitten av 1900-talet, kan siffran ha varit så hög som hälften av jordens befolkning.</p>
<p>För att sätta sifforna över hunger och svält i världen i vår samtid i sitt rätta perspektiv bör GRFC-rapporten läsas tillsammans med annan litteratur och jämföras med annan data. Det finns inga tecken, <em>än så länge</em>, på att livsmedelsproduktionen – på global eller kontinental skala – påverkats allvarligt negativt av den globala uppvärmningen. Den globala produktionen av de viktigaste baslivsmedlen har nämligen fortsatt att <em>öka</em>, och variationen från år till år tycks inte heller ha förändrats, fastän extrem torka regionalt fördärvat skördar år efter år på somliga platser – torka som i <em>vissa</em> fall sannolikt delvis kan attribueras till effekter av den globala uppvärmningen.</p>
<p>Den lokala bristen på livsmedelsresurser utgör ett problem, men någon verklig global brist på livsmedel råder inte.</p>
<h2>Orsaker till dagens svält</h2>
<p>Anledningarna till svält och livsmedelsosäkerhet är i GRFC-rapporten uppdelade i väpnade konflikter, ”extrem” väderlek som föranlett missväxt och olika ekonomiska chocker. Svält eller livsmedelsbrist har sällan bara en enda orsak. I stället brukar flera faktorer samverka och ge upphov till negativa synergier, som <em>tillsammans</em> bäddar för en akut försörjningskris. Det innebär dels att monokausala förklaringar i de flesta fall är olämpliga, dels att det är svårt att vikta vilken betydelse varje enskild faktor har.</p>
<p>Ren svält förekommer främst i länder plågade av väpnade konflikter (figur 1). Dessa stör jordbruksproduktion, handel och annan ekonomisk aktivitet. Dessutom förstörs egendom och infrastruktur, och människor drivs på flykt och in i extrem fattigdom. Även humanitärt biståndsarbete hindras av väpnade konflikter. Ibland används hungern också mer eller mindre medvetet som ett vapen. I GRFC-rapporten konstateras det emellertid att ytterligare en faktor, vid sidan om väpnade konflikter, brukar krävas för att svält ska uppstå. Samtliga regioner som 2021 led av en omfattande och akut livsmedelskris var också påverkade av antingen väderrelaterad missväxt eller ekonomiska chocker av olika slag – eller av bägge delarna.</p>
<p>Antalet människor som upplever allvarlig livsmedelsbrist har alltså ökat sedan 2019. Det är delvis en direkt eller indirekt konsekvens av ekonomiska chocker från olika restriktioner under covid-19-pandemin. Effekten av dem har tenderat, även i rikare länder, att drabba de fattigaste och mest socialt utsatta oproportionerligt hårt. Dessutom har pandemin minskat fokuset på att bekämpa hungersnöd när kampen mot viruset hamnat i centrum, innan nu kriget mellan Ukraina och Ryssland i ännu högre grad gjort det. Därtill har, men i mindre utsträckning, världshandeln med livsmedel störts och blivit dyrare på grund av bland annat en containerbrist, som delvis hör samman med pandemin.</p>
<p>All typ av missväxt, eller överdödlighet bland tamdjur, som bidrar till allvarlig livsmedelsbrist klumpas i GRFC-rapporten ihop under begreppet ”extremväder”. Den vanligaste orsaken är torka. Långvarig och svår torka är på många håll i världen ett återkommande problem. Det behöver inte utgöra något ”extremväder” i begreppets betydelse inom klimatforskningen. Det finns vidare en risk att somliga läsare av GRFC-rapporten förknippar hunger orsakad av ”extremväder” med effekter av den globala uppvärmningen.</p>
<blockquote><p>Förr i tiden svalt betydligt fler människor på grund av ”extremväder” än idag.</p></blockquote>
<p>Medan vissa typer av extremväder (såsom värmeböljor) – särskilt på somliga platser i världen – tveklöst ökar på sikt i ett successivt allt varmare klimat är missväxt, och efterföljande hunger, till följd av ”extremväder” inte något som först och främst kan tillskrivas den globala uppvärmningen (några sådana påståenden görs inte heller i rapporten). Historiskt sett har vad som GRFC-rapporten, lite missvisande, kallar ”extremväder” varit den främsta orsaken till hungersnöd i världen. Förr i tiden svalt betydligt fler människor på grund av ”extremväder” än idag.</p>
<p>Svält på grund av väderrelaterad missväxt förekommer idag endast i institutionellt mycket svaga och instabila samhällen utan skyddsnät och med en dåligt utvecklad infrastruktur.</p>
<h2>Strukturella orsaker till hungersnöd</h2>
<p>Vilka faktorer, förutom väpnade konflikter, förklarar då förekomsten av hunger på 2000-talet? Något samband med klimatförhållanden är svårt att finna förutom att hungern främst är koncentrerad till områden med ett tropiskt klimat. Det är emellertid knappast klimatet i sig, eller klimatförändringar för den delen, som förklarar hungern. Andra, samhälleliga snarare än naturgeografiska, faktorer avgör istället hungerns geografi (se figur 2).</p>
<figure id="attachment_74259" aria-describedby="caption-attachment-74259" style="width: 1287px" class="wp-caption alignnone"><img decoding="async" class="wp-image-74259 size-full" src="https://kvartal.se/wp-content/uploads/2022/09/2.png" alt="" width="1287" height="685" data-wp-pid="74259" srcset="https://kvartal.se/wp-content/uploads/2022/09/2.png 1287w, https://kvartal.se/wp-content/uploads/2022/09/2-600x319.png 600w, https://kvartal.se/wp-content/uploads/2022/09/2-300x160.png 300w, https://kvartal.se/wp-content/uploads/2022/09/2-768x409.png 768w" sizes="(max-width: 1287px) 100vw, 1287px" /><figcaption id="caption-attachment-74259" class="wp-caption-text">Figur 2: Karta över hungers utbredning i olika länder i världen enligt <em>Global hunger index</em> (GHI) från 2021. Detta index, som löper från 0 till 100, kombinerar fyra olika faktorer: andel av befolkningen som är undernärd, förekomsten av avmagring<strong> </strong>hos barn under fem års ålder, förekomsten av hämmad tillväxt hos barn under fem år och andel barn som dör under fem års ålder.</figcaption></figure>
<p>Väl medveten om att korrelation inte innebär kausalitet genomförde jag en rad korrelationsanalyser mellan data över andelen kroniskt undernärda i olika länder och en rad andra samhälleliga faktorer (se figur 3).</p>
<p>Ungefär en fjärdedel av variationen i förekomsten av hunger kan förklaras med graden av auktoritärt styre. Det stämmer väl in med vad nobelpristagaren i ekonomi <strong>Amartya Sen</strong> noterat för årtionden sedan: svält förekommer sällan i demokratier. Medan den observationen tycks hålla väl även på 2020-talet så förklarar graden av auktoritärt styre alltså bara knappt en fjärdedel av variationen i förekomsten av hunger i olika länder.</p>
<blockquote><p>Hunger är en krutdurk för social oro och krav på regimförändringar.</p></blockquote>
<p>I många av de hårdaste diktaturerna i världen är livsmedelsförsörjningen numera mycket god. Svält förekommer främst i ”dysfunktionella” diktaturer. Hunger är en krutdurk för social oro och krav på regimförändringar. Historiskt sett har det också alltid varit det. Det är därför något som de flesta ”välfungerande” diktatoriska regimer gör vad de kan för att undvika.</p>
<figure id="attachment_74260" aria-describedby="caption-attachment-74260" style="width: 410px" class="wp-caption alignnone"><img decoding="async" class="wp-image-74260 size-full" src="https://kvartal.se/wp-content/uploads/2022/09/3.png" alt="" width="410" height="573" data-wp-pid="74260" srcset="https://kvartal.se/wp-content/uploads/2022/09/3.png 410w, https://kvartal.se/wp-content/uploads/2022/09/3-215x300.png 215w" sizes="(max-width: 410px) 100vw, 410px" /><figcaption id="caption-attachment-74260" class="wp-caption-text">Figur 3: Det statistiska sambandet (övre grafen) mellan omfattningen av hunger (mätt utifrån GHI) och bristen på demokrati (mätt utifrån <em>Economist intelligence unit democracy index</em> 2021) och det statistiska sambandet (nedre grafen) mellan omfattningen av hunger (mätt genom GHI) och det genomsnittliga antalet barn per kvinna (enligt data för 2021 från FN:s Befolkningssektionen vid avdelningen för ekonomisk och social utveckling). Förklaringsgraden (determinationskoefficienten, R2) visas tillsammans med den linjära regressionslinjen i de bägge graferna.</figcaption></figure>
<p>Den enskilda faktor, som undertecknad kunnat finna, som bäst korrelerar med förekomsten av hunger är antalet barn per kvinna. Ett högt antal barn per kvinna samvarierar i hög grad med de länder med lägst samhällelig utvecklings- och utbildningsnivå och är knappast i sig orsaken till hunger, utan snarare ett symtom på samma faktorer som skapar förutsättningar för hungersnöd (se figur 4). Denna variabel förklarar omkring 43 procent av variationen i andelen undernärda i olika länder (se figur 3).</p>
<p>I länder med många barn per kvinna är det vanligare att det förekommer hungrande människor. I dessa länder är andelen av befolkningen som lider av kronisk undernäring som högst (se figur 2). Det finns emellertid ett fåtal länder, med få barn per kvinna, med en hög andel hungrande. Till exempel Nordkorea.</p>
<figure id="attachment_74261" aria-describedby="caption-attachment-74261" style="width: 1306px" class="wp-caption alignnone"><img decoding="async" class="wp-image-74261 size-full" src="https://kvartal.se/wp-content/uploads/2022/09/4.png" alt="" width="1306" height="698" data-wp-pid="74261" srcset="https://kvartal.se/wp-content/uploads/2022/09/4.png 1306w, https://kvartal.se/wp-content/uploads/2022/09/4-600x321.png 600w, https://kvartal.se/wp-content/uploads/2022/09/4-300x160.png 300w, https://kvartal.se/wp-content/uploads/2022/09/4-768x410.png 768w" sizes="(max-width: 1306px) 100vw, 1306px" /><figcaption id="caption-attachment-74261" class="wp-caption-text">Figur 4: Karta över genomsnittligt antal barn per kvinna på nationell nivå. Observera att större delen av Asien och Latinamerika numera har mindre än tre barn per kvinna och många länder där numera har lika få som i europeiska länder. Ett högt antal barn per kvinna är idag nästan uteslutande koncentrerat till afrikanska länder.</figcaption></figure>
<p>Hur som helst korrelerar andelen undernärda betydligt starkare med antalet barn per kvinna än graden av auktoritärt styre. Vilken kausalitet som kan inläsas häri ter sig oklart. Det är inte säkert att en hög befolkningstillväxt i sig är den främsta orsaken till hunger, utan snarare att de länder med flest barn per kvinna också är de mest instabila och minst utvecklade länderna där förutsättningarna för livsmedelsbrist är störst.</p>
<blockquote><p>Möjligheterna är emellertid goda att i princip utrota åtminstone akut svält med förhållandevis små medel.</p></blockquote>
<p>Tillsammans kan alltså antalet barn per kvinna och graden av auktoritärt styre i mycket hög grad predicera de geografiska skillnaderna i förekomsten av undernäring i världen. Länder med en stor hungrande befolkning har, med få undantag, åtminstone endera. Det bör också påpekas att antalet barn per kvinna och graden av demokrati inte heller är oberoende av varandra. Nästan en tredjedel av variationen i graden av demokrati kan nämligen prediceras av antalet barn per kvinna: antalet barn per kvinna tenderar att vara högre i diktaturer än i demokratier. Sambandet försvagas dock om europeiska länder, alltså demokratier med få barn per kvinna, exkluderas ur beräkningen.</p>
<h2>Fred bästa vapnet mot hunger</h2>
<p>Vi ser nu ett, möjligen bara tillfälligt, brott i den trend mot minskad svält i världen som pågått i årtionden. Akut svält på 2020-talet är nära kopplad till väpnade konflikter men inträffar som vi sett normalt först när minst en annan ytterligare faktor, såsom torka, minskar livsmedelstillgången. Då kan allvarlig hungersnöd slå till i områden som har en kroniskt låg livsmedelssäkerhet och svår fattigdom. Såväl omfattande kronisk undernäring som akut svält är, föga förvånande, centrerad till länder med låg samhällelig utvecklingsnivå, extrem fattigdom, bristande institutioner och infrastruktur – något som i sin tur sammanfaller i hög grad med många barn per kvinna.</p>
<p>I och med att den globala extrema fattigdomen mer än halverats sedan 1990, och många av FN:s millenniemål uppnåddes fortare än förväntat, samtidigt som befolkningstillväxten i världen avtar i hastighet kan vi vänta oss en fortsatt minskning av hunger. Det kommer dock att ta ytterligare årtionden, minst, innan de strukturella faktorerna bakom svält helt undanröjs. Dessutom är det inte en naturlag att den långsiktiga utvecklingen fortsätter som hittills.</p>
<p>I nuläget är mer kraftfulla humanitära biståndsåtgärder avgörande för att säkra livsmedelsförsörjningen i de återkommande akuta kriserna i delar av världen. Möjligheterna är emellertid goda att i princip utrota åtminstone akut svält med förhållandevis små medel.</p>
<p>Fred är dock det i särklass bästa receptet för att motverka att hungerskriser alls inträffar.</p>
<div class="author-byline">Fredrik Charpentier Ljungqvist är docent i både historia och naturgeografi vid Stockholms universitet.
</div>
</div>
