9.3 Programmering med følger og rekker

Når datamaskinen tar over regnearbeidet

Du har lært å finne det femtiende leddet i en følge med formler — men hva om rekursjonen er så kronglete at ingen eksplisitt formel finnes? Eller om du vil se de tusen første delsummene av en rekke for å se om den konvergerer? Da setter du datamaskinen i arbeid.

Programmering er et kraftig supplement til analytisk matematikk. Med Python kan du generere hundrevis av ledd umiddelbart, selv for kompliserte rekursive formler, visualisere konvergens og divergens grafisk, eksperimentere med parametre og se effekten med én gang, og modellere praktiske situasjoner der analytiske formler blir for tunge.

Verktøyene er få og enkle. To løkketyper gjør jobben: en for-løkke når du vet nøyaktig hvor mange iterasjoner du trenger («beregn de første 50 leddene»), og en while-løkke når du itererer til en betingelse er oppfylt («kjør til feilen er under $10^{-6}$»). I tillegg bruker vi matplotlib til plotting og math til matematiske funksjoner. I denne fortellingen oversetter vi hele følge- og rekketeorien til kode — og lar maskinen avsløre ting formlene ikke uten videre ser.

Følger og delsummer i kode

En eksplisitt følge beregnes direkte i en for-løkke. Den geometriske $a_n = 100 \cdot 0{,}85^{n-1}$:

a1 = 100
k = 0.85
for n in range(1, 21):
    a_n = a1 * k**(n - 1)
    print(f"a_{n:>2} = {a_n:.4f}")

En rekursiv følge programmeres ved å oppdatere en variabel i hver runde. Rekursjonen $a_{n+1} = 0{,}7a_n + 15$ med $a_1 = 200$:

a = 200
for n in range(2, 21):
    a = 0.7 * a + 15

Linjen a = 0.7 * a + 15 er hele modellen — gammel verdi inn, ny verdi ut. (Likevekten kan du forutsi analytisk: $L = 0{,}7L + 15$ gir $L = 50$ — og koden bekrefter at leddene siger mot 50.)

Delsummer beregnes med en akkumulator — en sumvariabel som vokser for hvert ledd. Slik utforskes den berømte rekken $\displaystyle \sum \frac{1}{n^2}$:

S = 0
for n in range(1, 101):
    S += 1 / n**2

Plotter du delsummene $S_n$ mot $n$ med matplotlib (med plt.plot, aksetekster og plt.axhline for en referanselinje), ser du kurven flate ut mot $\displaystyle \frac{\pi^2}{6} \approx 1{,}6449$ — Eulers klassiske resultat, demonstrert på tre kodelinjer.

While-løkker: kjør til noe skjer

Ofte vet du ikke på forhånd hvor mange iterasjoner som trengs — du vet bare når du skal stoppe. Da er while-løkken verktøyet. Første eksempel: når faller den geometriske følgen $a_n = 500 \cdot 0{,}9^{n-1}$ under 1?

a = 500
n = 1
while a >= 1:
    a = a * 0.9
    n += 1

Løkken kjører så lenge betingelsen holder, og når den brytes, holder $n$ svaret. Andre eksempel er en juvel: Newtons metode for kvadratrøtter er selv en rekursiv følge, $\displaystyle a_{n+1} = \frac{1}{2}\left(a_n + \frac{c}{a_n}\right) \to \sqrt{c}$. For $\sqrt{3}$:

a = 2.0
toleranse = 1e-10
while True:
    a_ny = (a + 3 / a) / 2
    if abs(a_ny - a) < toleranse:
        break
    a = a_ny

Her itererer vi til endringen mellom to ledd er under toleransen — og det skjer fort: Newtons metode har kvadratisk konvergens, antall korrekte desimaler omtrent dobles per iterasjon. Fire-fem runder gir ti desimaler.

Kontrasten er lærerik: Leibniz-rekken $\displaystyle \frac{\pi}{4} = 1 - \frac{1}{3} + \frac{1}{5} - \frac{1}{7} + \cdots$ konvergerer også — men grusomt sakte; tusenvis av ledd gir bare noen få desimaler av $\pi$. Konvergenshastighet er altså en egenskap ved metoden, ikke bare ved svaret, og valg av algoritme betyr enormt i praksis. Numerikk handler ikke bare om å få riktig svar, men om å få det før batteriet dør.

Modeller: lån, p-rekker og populasjoner

Nå setter vi verktøyene i arbeid på tre ordentlige problemer.

Lånet. Du låner 500 000 kroner til 5 % årlig rente og betaler 35 000 kroner i året. Restgjelden følger rekursjonen $a_{n+1} = 1{,}05 \cdot a_n - 35\,000$ med $a_0 = 500\,000$ — renter på, betaling av. En while-løkke (while a > 0:) som oppdaterer gjelden og teller år, viser at lånet er nedbetalt etter cirka 24 år; lagrer du verdiene i lister og plotter dem, ser du gjeldskurven krumme seg nedover — flatt i starten (rentene spiser mesteparten av betalingen), bratt mot slutten.

p-rekkene. Hvilke rekker $\displaystyle \sum_{n=1}^{\infty} \frac{1}{n^p}$ konvergerer? En for-løkke over $p$-verdiene $0{,}5$, $1$, $1{,}5$ og $2$ med akkumulator opp til $N = 10\,000$ gir tallenes tale: $S_{10\,000} \approx 198{,}5$ for $p = 0{,}5$ (divergerer åpenbart), $\approx 9{,}79$ for $p = 1$ (den harmoniske rekken — divergerer, men i sneglefart), $\approx 2{,}612$ for $p = 1{,}5$ og $\approx 1{,}6449$ for $p = 2$ (begge konvergerer). Numerikken antyder grensen ved $p = 1$ — og teorien bekrefter: konvergens hvis og bare hvis $p > 1$.

Populasjonen. Den logistiske rekursjonen $\displaystyle P_{n+1} = r P_n \left(1 - \frac{P_n}{K}\right)$ med $r = 2{,}8$, $K = 1000$ og $P_0 = 100$ simuleres med samme mønster — én oppdateringslinje i en løkke. Plottet viser at populasjonen svinger seg inn mot likevekten $\displaystyle P^* = K\left(1 - \frac{1}{r}\right) \approx 643$.

To advarsler fra skyttergravene til slutt: Python er 0-indeksert og range(1, n) stopper på $n - 1$ — klassiske kilder til av-med-én-feil. Og listeforståelser som [a1 * k**(n-1) for n in range(1, 21)] gir kompakt kode når du vil lage hele følgen på én linje. GeoGebra kan brukes til tilsvarende utforskninger, men matplotlib er standardvalget i Python.

Oppsummering: teorien i tastene

Følge- og rekketeorien fikk en maskin som medspiller. For-løkker håndterer kjent antall iterasjoner, while-løkker kjører til en betingelse brytes — «første ledd under 1», «endring under toleransen». Rekursive følger ble til én oppdateringslinje (a = p*a + q), delsummer til en akkumulator (S += ledd), og matplotlib gjorde konvergens synlig som kurver som flater ut.

Modellene viste spennvidden: lånerekursjonen $a_{n+1} = 1{,}05a_n - 35\,000$ avslørte 24 års nedbetalingstid, p-rekkene tegnet grensen mellom konvergens ($p > 1$) og divergens, og den logistiske populasjonen svingte seg inn mot $\displaystyle P^* = K(1 - \frac{1}{r}) \approx 643$. Newtons metode $\displaystyle a_{n+1} = \frac{1}{2}(a_n + \frac{c}{a_n})$ demonstrerte at konvergenshastighet er en egenskap ved metoden — kvadratisk konvergens dobler antall riktige desimaler per runde, mens Leibniz-rekken for $\displaystyle \frac{\pi}{4}$ kravler mot målet.

Husk håndverksdetaljene — 0-indeksering, eksklusive range-grenser, listeforståelser for kompakte følger — og husk arbeidsdelingen: analysen gir innsikt og bevis, numerikken gir utforskning og bekreftelse. Sammen er de sterkere enn hver for seg, og det er nettopp slik moderne matematikk drives — med penn i den ene hånden og tastatur i den andre.