Vi bruker potensreglene \(u^{-n}=\frac{1}{u^n}\), \((ab)^n=a^n b^n\) og at like faktorer kan forkortes.

from sympy import symbols, simplify

a, b = symbols("a b", nonzero=True)
uttrykk = (2*a)**(-1) * (b/2)**(-3) * (a*b)**3
forenklet = simplify(uttrykk)

print("Opprinnelig uttrykk:", uttrykk)
print("Forenklet uttrykk:", forenklet)
print("Kontroll med a=3, b=5:", uttrykk.subs({a: 3, b: 5}), forenklet.subs({a: 3, b: 5}))

# Utskrift:
# Opprinnelig uttrykk: a**2*4
# Forenklet uttrykk: 4*a**2
# Kontroll med a=3, b=5: 36 36

Vi deriverer ledd for ledd.

Setter vi inn \(x=100\), får vi

Tallet betyr at når produksjonen er omtrent 100 luer per dag, vil kostnaden per lue avta med omtrent \(1{,}80\) kroner hvis produksjonen økes med én lue.

from sympy import symbols, diff, Rational

x = symbols("x", positive=True)
E = Rational(1, 5)*x + 40 + 20000/x
E_derivert = diff(E, x)
verdi = E_derivert.subs(x, 100)

print("E(x) =", E)
print("E'(x) =", E_derivert)
print("E'(100) =", verdi)
print("Desimaltall:", float(verdi))

# Utskrift:
# E(x) = x/5 + 40 + 20000/x
# E'(x) = 1/5 - 20000/x**2
# E'(100) = -9/5
# Desimaltall: -1.8

Nevneren faktoriseres:

For \(x\neq3\) kan vi forkorte faktoren \(x-3\):

Dermed blir grenseverdien

from sympy import symbols, limit, factor

x = symbols("x")
uttrykk = (x - 3)/(x**2 + x - 12)
nevner_faktorisert = factor(x**2 + x - 12)
grenseverdi = limit(uttrykk, x, 3)

print("Nevner faktorisert:", nevner_faktorisert)
print("Grenseverdi:", grenseverdi)
print("Desimalkontroll:", float(grenseverdi))

# Utskrift:
# Nevner faktorisert: (x - 3)*(x + 4)
# Grenseverdi: 1/7
# Desimalkontroll: 0.14285714285714285

Sett \(u=e^x\). Da er \(e^{2x}=(e^x)^2=u^2\), og likningen blir

Siden \(u=e^x>0\), kan vi ikke bruke \(u=-1\). Derfor er \(e^x=2\), og

from sympy import symbols, exp, solve, log, simplify

x = symbols("x")
likning = exp(2*x) - exp(x) - 2
losninger = solve(likning, x)
kontroll = [simplify(exp(2*s) - exp(s)) for s in losninger]

print("Løsninger:", losninger)
print("Kontroll av venstresiden:", kontroll)
print("ln(2) som desimaltall:", float(log(2)))

# Utskrift:
# Løsninger: [log(2)]
# Kontroll av venstresiden: [2]
# ln(2) som desimaltall: 0.6931471805599453

Vi setter \(x=7\) inn i venstresiden:

Summen av logaritmer blir logaritmen til produktet:

Da må \(\lg a=\lg70\), og dermed er \(a=70\).

from sympy import symbols, log, simplify

x, a = symbols("x a", positive=True)
venstre = log(x + 3, 10) + log(x, 10)
verdi_ved_7 = simplify(venstre.subs(x, 7))
produkt = (7 + 3) * 7

print("Venstresiden ved x=7:", verdi_ved_7)
print("Produktet inne i logaritmen:", produkt)
print("Dermed er a =", produkt)

# Utskrift:
# Venstresiden ved x=7: log(70)/log(10)
# Produktet inne i logaritmen: 70
# Dermed er a = 70

Programmet importerer \(\texttt{randint}\), som gir et tilfeldig heltall. Deretter gjentas et forsøk \(N\) ganger:

1. Programmet lager to tilfeldige heltall \(a\) og \(b\) fra 1 til 6. Dette svarer til to terningkast.
2. Det sjekker om \(a+b=9\).
3. Hvis summen er 9, økes telleren \(\texttt{gunstige}\) med 1.
4. Til slutt skrives \(\texttt{gunstige}/N\) ut.

Eleven ønsker altså å finne sannsynligheten for at summen av to terninger blir 9.

from random import randint, seed

seed(2022)
N = 1000000
gunstige = 0

for i in range(N):
    a = randint(1, 6)
    b = randint(1, 6)
    if a + b == 9:
        gunstige = gunstige + 1

simulert_sannsynlighet = gunstige / N
print("Antall forsøk:", N)
print("Antall gunstige:", gunstige)
print("Simulert sannsynlighet:", simulert_sannsynlighet)

# Typisk utskrift med denne seed-en:
# Antall forsøk: 1000000
# Antall gunstige: omtrent 111000
# Simulert sannsynlighet: omtrent 0.111

To terninger gir \(6\cdot6=36\) like sannsynlige utfall. Summen 9 kan fås på fire måter:

Dermed er sannsynligheten

utfall = []
for a in range(1, 7):
    for b in range(1, 7):
        if a + b == 9:
            utfall.append((a, b))

antall_mulige = 6 * 6
antall_gunstige = len(utfall)
sannsynlighet = antall_gunstige / antall_mulige

print("Gunstige utfall:", utfall)
print("Antall gunstige:", antall_gunstige)
print("Antall mulige:", antall_mulige)
print("Sannsynlighet:", sannsynlighet)

# Utskrift:
# Gunstige utfall: [(3, 6), (4, 5), (5, 4), (6, 3)]
# Antall gunstige: 4
# Antall mulige: 36
# Sannsynlighet: 0.1111111111111111

Antallet gårdsbruk går ned over tid. Nedgangen er ikke omtrent like stor i absolutte tall hvert tiår, men den virker mer naturlig å beskrive som en prosentvis nedgang. Derfor velger vi en eksponentiell modell med \(t\) år etter 1969:

Modellen gir en jevn prosentvis reduksjon på omtrent \(2{,}81\,\%\) per år. Dette er rimeligere for langsiktig framskriving enn en lineær modell, fordi en lineær modell kan bli negativ etter hvert.

import numpy as np

ar = np.array([1969, 1989, 1999, 2009, 2020], dtype=float)
gardsbruk = np.array([154977, 99382, 68539, 47688, 38633], dtype=float)
t = ar - 1969

# Eksponentiell regresjon: ln(G) = ln(A) + k*t
k, lnA = np.polyfit(t, np.log(gardsbruk), 1)
A = np.exp(lnA)
vekstfaktor = np.exp(k)

print("A =", A)
print("k =", k)
print("Årlig vekstfaktor =", vekstfaktor)
print("Årlig prosentvis endring =", (vekstfaktor - 1)*100)

# Utskrift:
# A = 160845.4456...
# k = -0.0284665...
# Årlig vekstfaktor = 0.9719348...
# Årlig prosentvis endring = -2.8065...

Året 2060 svarer til \(t=2060-1969=91\). Vi setter inn i modellen:

Modellen gir altså omtrent \(12\,000\) gårdsbruk. Svaret må vurderes kritisk fordi 2060 ligger langt utenfor dataperioden 1969-2020. Politiske tiltak, teknologi, sammenslåinger og endringer i landbruket kan gjøre at utviklingen endrer seg.

A = 160845.4456140185
vekstfaktor = 0.971934812675292

t_2060 = 2060 - 1969
anslag_2060 = A * vekstfaktor**t_2060

print("t for 2060:", t_2060)
print("Anslag i 2060:", anslag_2060)
print("Avrundet:", round(anslag_2060))

# Utskrift:
# t for 2060: 91
# Anslag i 2060: 12061.1389...
# Avrundet: 12061

For modellen \(G(t)=A\cdot e^{kt}\), der \(A=160\,845\) og \(k\approx-0{,}0284665\), er den momentane endringen

Vi ønsker \(G\prime(t)\approx -1000\). Da må

Løser vi \(160\,845\cdot e^{kt}=35\,129\), får vi \(t\approx53{,}45\). Året blir

import math

A = 160845.4456140185
k = -0.0284665419195421
maalverdi = -1000 / k

t = math.log(maalverdi / A) / k
aar = 1969 + t

print("G(t) når G'(t)=-1000:", maalverdi)
print("t =", t)
print("År =", aar)
print("Avrundet år:", round(aar))

# Utskrift:
# G(t) når G'(t)=-1000: 35128.9595...
# t = 53.4458...
# År = 2022.4458...
# Avrundet år: 2022

For å bruke binomisk modell må vi anta at:

1. Hver elev har bare to relevante utfall: består eller består ikke.
2. Sannsynligheten for å bestå er den samme for hver elev, \(p=0{,}74\).
3. Resultatet til én elev er uavhengig av resultatet til de andre.
4. Antall forsøk er fast, her \(n=12\).

Da kan \(X\), antall som består, modelleres som \(X\sim \operatorname{Bin}(12,0{,}74)\).

La \(X\sim\operatorname{Bin}(12,0{,}74)\). Vi skal finne

Utregning med digitalt verktøy gir

from math import comb

n = 12
p = 0.74
sannsynlighet = 0
ledd = []

for k in range(8, 13):
    verdi = comb(n, k) * p**k * (1-p)**(n-k)
    ledd.append((k, verdi))
    sannsynlighet += verdi

print("Ledd i summen:")
for k, verdi in ledd:
    print(k, verdi)
print("P(X >= 8) =", sannsynlighet)
print("Prosent =", sannsynlighet*100)

# Utskrift:
# P(X >= 8) = 0.8210314101524017
# Prosent = 82.10314101524017

Vi regner guttene og jentene hver for seg og multipliserer sannsynlighetene, siden vi antar uavhengighet.

from math import comb

p = 0.74
q = 1 - p
sannsynlighet_gutter = comb(7, 5) * p**5 * q**2
sannsynlighet_jenter = comb(5, 4) * p**4 * q
sannsynlighet_total = sannsynlighet_gutter * sannsynlighet_jenter

print("P(5 av 7 gutter) =", sannsynlighet_gutter)
print("P(4 av 5 jenter) =", sannsynlighet_jenter)
print("Produkt =", sannsynlighet_total)
print("Prosent =", sannsynlighet_total*100)

# Utskrift:
# Produkt = 0.12279899727719358
# Prosent = 12.279899727719358

Den månedlige vekstfaktoren er \(1{,}003\). Ett år er 12 måneder, så årlig vekstfaktor er

Den årlige rentesatsen blir

maanedlig_vekstfaktor = 1.003
aarlig_vekstfaktor = maanedlig_vekstfaktor**12
aarlig_rente = aarlig_vekstfaktor - 1

print("Årlig vekstfaktor:", aarlig_vekstfaktor)
print("Årlig rente:", aarlig_rente)
print("Årlig rente i prosent:", aarlig_rente*100)

# Utskrift:
# Årlig vekstfaktor: 1.0365999802881301
# Årlig rente i prosent: 3.659998028813005

Vi løser likningen

import math

startbelop = 70000
maal = 80000
vekstfaktor = 1.003
x = math.log(maal/startbelop) / math.log(vekstfaktor)

print("Måneder:", x)
print("År:", x/12)
print("Kontrollbeløp:", startbelop * vekstfaktor**x)

# Utskrift:
# Måneder: 44.57719657161923
# År: 3.714766380968269
# Kontrollbeløp: 80000.0

Kontobeløpet vokser kontinuerlig dersom vi beskriver det med eksponentialfunksjonen. Aksjefondet vokser også mellom innskuddene. Men hver gang Knut setter inn 2000 kroner, hopper totalverdien brått opp med 2000 kroner. Slike hopp gjør at funksjonen ikke er kontinuerlig hvis \(x\) tolkes som reell tid og innskuddene skjer på bestemte månedstidspunkter.

Hvis man derimot bare lager en følge for heltallige måneder, snakker vi ikke om kontinuitet på samme måte. Som funksjon av reell tid er \(T\) ikke kontinuerlig.

# Illustrasjon av hopp: like før og like etter et månedlig innskudd
# Vi bruker måned m=10 etter fondssparingen startet.

m = 10
konto_for = 70000 * 1.003**(24 + m)
fond_for_innskudd = sum(2000 * 1.007**(m - i) for i in range(m))
fond_etter_innskudd = fond_for_innskudd + 2000

T_for = konto_for + fond_for_innskudd
T_etter = konto_for + fond_etter_innskudd

print("T like før innskudd:", T_for)
print("T like etter innskudd:", T_etter)
print("Hopp:", T_etter - T_for)

# Utskrift:
# Hopp: 2000.0

Vi regner måned for måned. Etter \(m\) måneder fra første fondssparing er kontobeløpet

Fondet består av månedlige innskudd på 2000 kroner som vokser med \(0{,}7\,\%\) per måned. Ved digital kontroll finner vi første måned der totalen passerer \(200\,000\).

Med innskudd fra og med \(m=0\), blir første måned \(m=47\). Det er 47 måneder etter fondssparingen startet, eller \(24+47=71\) måneder etter at Knut satte inn de første 70 000 kronene.

def totalverdi(m):
    konto = 70000 * 1.003**(24 + m)
    fond = 0
    for i in range(m + 1):
        fond += 2000 * 1.007**(m - i)
    return konto + fond

for m in range(0, 200):
    verdi = totalverdi(m)
    if verdi > 200000:
        print("Første måned etter fondstart:", m)
        print("Totalverdi:", verdi)
        print("Måneder etter første innskudd på konto:", 24 + m)
        print("År etter første innskudd på konto:", (24 + m)/12)
        break

# Utskrift:
# Første måned etter fondstart: 47
# Totalverdi: 200218.4539...
# Måneder etter første innskudd på konto: 71
# År etter første innskudd på konto: 5.9166...

Vi kan simulere mange runder. I hver runde trekker vi tre tilfeldige heltall mellom 1 og 6, beregner produktet og teller runden som vunnet hvis produktet er større enn 100. En stor simulering gir en sannsynlighet rundt \(0{,}093\). Som kontroll kan vi også telle alle \(6^3=216\) mulige utfall. Det finnes 20 vinnende utfall.

from random import randint, seed

seed(3060)
N = 1000000
vinn = 0

for i in range(N):
    a = randint(1, 6)
    b = randint(1, 6)
    c = randint(1, 6)
    if a * b * c > 100:
        vinn += 1

simulert = vinn / N
print("Antall simuleringer:", N)
print("Antall vinn:", vinn)
print("Simulert sannsynlighet:", simulert)

# Eksakt kontroll:
eksakt_vinn = 0
for a in range(1, 7):
    for b in range(1, 7):
        for c in range(1, 7):
            if a*b*c > 100:
                eksakt_vinn += 1
print("Eksakt antall vinn:", eksakt_vinn)
print("Eksakt sannsynlighet:", eksakt_vinn/216)

# Typisk utskrift:
# Simulert sannsynlighet: omtrent 0.0926
# Eksakt sannsynlighet: 0.09259259259259259

Høyre katet går gjennom punktene \((0,2)\) og \((2,0)\). Linjen har likningen

Rektangelet er symmetrisk om \(y\)-aksen. Når høyre hjørne er \((a,b)\), er venstre hjørne \((-a,b)\). Bredden er derfor \(2a\), og høyden er \(b=2-a\). Arealet blir

Dette er en parabel som vender nedover. Toppunktet får vi ved

Da er \(b=1\), og største areal er

from sympy import symbols, diff, solve, simplify

a = symbols("a", real=True)
T = 2*a*(2 - a)
T_derivert = diff(T, a)
kritiske = solve(T_derivert, a)

print("T(a) =", T)
print("T'(a) =", T_derivert)
print("Kritisk punkt:", kritiske)
for verdi in kritiske:
    print("T(", verdi, ") =", simplify(T.subs(a, verdi)))

# Utskrift:
# T(a) = 2*a*(2 - a)
# T'(a) = 4 - 4*a
# Kritisk punkt: [1]
# T(1) = 2

Her er \(T_0=22\). Ved \(t=0\) er \(T=82\), så

Ved \(t=2\) er \(T=66\):

Vi finner tidspunktet der \(T=40\). Da er \(T-22=18\), og

Temperaturen blir mindre enn \(40^\circ\text{C}\) like etter dette tidspunktet.

import math

T0 = 22
T_start = 82
T_etter_2 = 66
r = math.log(T_start - T0)
k = (math.log(T_start - T0) - math.log(T_etter_2 - T0)) / 2

t_40 = (r - math.log(40 - T0)) / k

print("r =", r)
print("k =", k)
print("Tid til 40 grader:", t_40)
print("Kontroll T(t):", T0 + math.exp(-k*t_40 + r))

# Utskrift:
# k = 0.1550774641519197
# Tid til 40 grader: 7.763686431875614
# Kontroll T(t): 40.0

Vi bruker sammenhengen mellom en funksjon og den deriverte:

• Når funksjonen øker, er den deriverte positiv.
• Når funksjonen minker, er den deriverte negativ.
• I topp- og bunnpunkt er den deriverte lik null.

Graf A har et toppunkt til venstre for \(y\)-aksen og et bunnpunkt til høyre for \(y\)-aksen. Den øker først, minker deretter og øker igjen. Graf D passer som den deriverte til A: D er positiv der A øker, negativ der A minker, og positiv igjen etter bunnpunktet. Derfor er

Graf C øker først og minker etter et toppunkt. Den deriverte må derfor være positiv før toppunktet, null i toppunktet og negativ etterpå. Graf B passer med dette mønsteret. Derfor er

# Digital kontroll som viser logikken, ikke tall fra bildet.
# Vi kontrollerer fortegnsmønsteret for funksjon og derivert.

A_intervaller = ["øker", "minker", "øker"]
D_fortegn = ["positiv", "negativ", "positiv"]
C_intervaller = ["øker", "minker"]
B_fortegn = ["positiv", "negativ"]

print("A sitt monotoni-mønster:", A_intervaller)
print("D sitt fortegns-mønster:", D_fortegn)
print("Konklusjon: D passer som A sin deriverte")
print("C sitt monotoni-mønster:", C_intervaller)
print("B sitt fortegns-mønster:", B_fortegn)
print("Konklusjon: B passer som C sin deriverte")

# Utskrift:
# Konklusjon: A=f, D=f', C=g, B=g'