Vi deriverer ledd for ledd. For eksponentialleddet bruker vi kjerneregelen: \((e^{u})\prime=e^{u}\cdot u\prime\). Her er \(u=-2x\), altså \(u\prime=-2\).

Polynomleddet deriveres med potensregelen:

Konstanten \(-2\pi\) har derivert lik null.

Et nullpunkt finner vi ved \(g(x)=0\). Faktoren \(\frac{1}{2}e^x\) er alltid positiv for alle reelle \(x\). Derfor må den kvadrerte faktoren være null:

Grafen skjærer eller berører derfor \(x\)-aksen i punktet \((\frac{1}{2},0 ight)\).

Skriv funksjonen som produktet \(g(x)=\frac{1}{2}\,u(x)v(x)\), der \(u(x)=e^x\) og \(v(x)=(2x-1)^2\). Da er \(u\prime(x)=e^x\), og med kjerneregelen får vi

Produktregelen gir

Faktoriser felles faktor:

Ekstremalpunkter kan bare oppstå der \(g\prime(x)=0\). Siden \(\frac{1}{2}e^x>0\), får vi

Dermed er \(x=\frac{1}{2}\) eller \(x=-\frac{3}{2}\).

Funksjonsverdiene er

Fortegnet til \((2x-1)(2x+3)\) viser at \(g\) øker før \(-\frac{3}{2}\), avtar mellom \(-\frac{3}{2}\) og \(\frac{1}{2}\), og øker etter \(\frac{1}{2}\). Derfor er \(-\frac{3}{2}\) et toppunkt og \(\frac{1}{2}\) et bunnpunkt.

import sympy as sp

x = sp.symbols('x')
g = sp.Rational(1, 2) * sp.exp(x) * (2*x - 1)**2
g_derivert = sp.diff(g, x)
kritiske_x = sp.solve(sp.Eq(g_derivert, 0), x)

print('g(x)       =', g)
print("g'(x)      =", sp.factor(g_derivert))
print('kritiske x =', kritiske_x)

for verdi in kritiske_x:
    y_verdi = sp.simplify(g.subs(x, verdi))
    print('punkt:', (verdi, y_verdi), '  numerisk:', float(y_verdi))

# Forventet utskrift:
# g(x)       = (2*x - 1)**2*exp(x)/2
# g'(x)      = (2*x - 1)*(2*x + 3)*exp(x)/2
# kritiske x = [-3/2, 1/2]
# punkt: (-3/2, 8*exp(-3/2))   numerisk: 1.785041281325...
# punkt: (1/2, 0)              numerisk: 0.0

Først isolerer vi potensen:

Siden \(81=3^4\), kan vi sammenligne eksponentene:

Da får vi

Vi må ha \(x>0\). Bruk logaritmereglene \(\lg x^2=2\lg x\) og \(\lg(x^{-9})=-9\lg x\):

Dette gir

Dermed er

Setter vi \(x=3\) i telleren, får vi \(3(9-3)=18\), mens nevneren går mot \(0\). Telleren går altså mot et positivt tall, mens nevneren skifter fortegn når \(x\) passerer 3.

Fra venstre er \(x-3<0\), og uttrykket går mot \(-\infty\). Fra høyre er \(x-3>0\), og uttrykket går mot \(+\infty\).

Den tosidige grenseverdien finnes derfor ikke.

Vi rasjonaliserer telleren:

For \(x e4\) kan vi forkorte \(x-4\):

Dermed blir grenseverdien

Treffsannsynligheten er \(p=0{,}80\). Siden skuddene er uavhengige, multipliserer vi sannsynlighetene:

La \(X\) være antall treff på tre skudd. Da er \(X\) binomisk fordelt med \(n=3\) og \(p=0{,}80\). Vi skal finne \(P(X=2)\):

Regningen gir

Høyst ett treff betyr \(X=0\) eller \(X=1\). Derfor

Vi regner:

Dermed er

from math import comb

n = 3
p_treff = 0.80
p_bom = 1 - p_treff

def binomisk(k):
    return comb(n, k) * p_treff**k * p_bom**(n-k)

p_begge_forste = p_treff * p_treff
p_noyaktig_to = binomisk(2)
p_hoyest_ett = binomisk(0) + binomisk(1)

print('P(treff på begge første) =', p_begge_forste)
print('P(nøyaktig to treff)     =', p_noyaktig_to)
print('P(høyst ett treff)       =', p_hoyest_ett)

# Forventet utskrift:
# P(treff på begge første) = 0.6400000000000001
# P(nøyaktig to treff)     = 0.3840000000000001
# P(høyst ett treff)       = 0.10399999999999998

Vi sammenligner venstregrense, høyregrense og funksjonsverdi.

Siden \(f(0)=2e^0=2\), får vi

Dermed er \(f\) kontinuerlig i \(x=0\).

Grensene fra venstre og høyre er fortsatt

Altså er \(\lim_{x\to0}g(x)=2\). Men funksjonsverdien er definert som

Siden grenseverdien ikke er lik funksjonsverdien, er \(g\) ikke kontinuerlig i \(x=0\).

De mulige sifrene er \(1,2,3,4,5,6\), altså 6 valg i hver av de tre posisjonene. Vi antar at samme siffer kan forekomme flere ganger, slik det vanligvis er på en tresifret kodelås.

Én av disse kodene er riktig. Sannsynligheten for riktig kode på første forsøk er derfor

Vi simulerer mange forsøk der riktig kode og Peders første gjetning velges tilfeldig blant de 216 mulige kodene. Andelen treff bør nærme seg \(\frac{1}{216}\).

import random

random.seed(2025)

sifre = ['1', '2', '3', '4', '5', '6']
koder = []
for a in sifre:
    for b in sifre:
        for c in sifre:
            koder.append(a + b + c)

antall_forsok = 200_000
treff = 0

for _ in range(antall_forsok):
    riktig_kode = random.choice(koder)
    forste_gjetning = random.choice(koder)
    if forste_gjetning == riktig_kode:
        treff += 1

simulert_sannsynlighet = treff / antall_forsok
teoretisk_sannsynlighet = 1 / len(koder)

print('antall mulige koder       =', len(koder))
print('antall simuleringer       =', antall_forsok)
print('antall treff              =', treff)
print('simulert sannsynlighet    =', simulert_sannsynlighet)
print('teoretisk sannsynlighet   =', teoretisk_sannsynlighet)

# Eksempel på utskrift:
# antall mulige koder       = 216
# antall simuleringer       = 200000
# antall treff              = omtrent 925
# simulert sannsynlighet    = omtrent 0.0046
# teoretisk sannsynlighet   = 0.004629629629629629

Simuleringen vil variere litt fra kjøring til kjøring, men med mange forsøk skal verdien ligge nær \(0{,}00463\).

La midtuttrykket være \(h(x)=ax^3+bx^2+cx+d\). Kontinuitet i \(x=-2\) gir

Kontinuitet i \(x=1\) gir

Derivasjonskravene gir

Dette gir et lineært likningssystem for \(a,b,c,d\). Løsningen er

import sympy as sp

x = sp.symbols('x')
a, b, c, d = sp.symbols('a b c d')
h = a*x**3 + b*x**2 + c*x + d
h_derivert = sp.diff(h, x)

likninger = [
    sp.Eq(h.subs(x, -2), 3),
    sp.Eq(h.subs(x, 1), -4),
    sp.Eq(h_derivert.subs(x, -2), -9),
    sp.Eq(h_derivert.subs(x, 1), 0)
]

losning = sp.solve(likninger, [a, b, c, d], dict=True)[0]
h_ferdig = sp.expand(h.subs(losning))

print('koeffisienter =', losning)
print('h(x)          =', h_ferdig)
print('h(-2)         =', sp.simplify(h_ferdig.subs(x, -2)))
print('h(1)          =', sp.simplify(h_ferdig.subs(x, 1)))
print("h'(-2)        =", sp.simplify(sp.diff(h_ferdig, x).subs(x, -2)))
print("h'(1)         =", sp.simplify(sp.diff(h_ferdig, x).subs(x, 1)))

# Forventet utskrift:
# koeffisienter = {a: -13/27, b: 7/9, c: -1/9, d: -113/27}
# h(x)          = -13*x**3/27 + 7*x**2/9 - x/9 - 113/27
# h(-2)         = 3
# h(1)          = -4
# h'(-2)        = -9
# h'(1)         = 0

Dermed er hele funksjonen bestemt.

Rekkefølgen spiller ingen rolle, så vi bruker kombinasjoner:

Minst to gutter betyr enten to gutter og to jenter, eller tre gutter og én jente. Antall gunstige grupper er

Totalt finnes \(\binom{10}{4}=210\) grupper. Derfor

Vi velger først hvilken av Emma og Marie som skal være med. Det kan gjøres på \(\binom{2}{1}=2\) måter. Deretter velger vi de tre andre gruppemedlemmene blant de 8 elevene som ikke er den andre av Emma og Marie:

Totalt finnes fortsatt \(210\) grupper. Dermed

from math import comb

totalt = comb(10, 4)
minst_to_gutter = comb(3, 2)*comb(7, 2) + comb(3, 3)*comb(7, 1)
akkurat_en_av_to = comb(2, 1)*comb(8, 3)

print('totalt antall grupper       =', totalt)
print('gunstige minst to gutter    =', minst_to_gutter)
print('P(minst to gutter)          =', minst_to_gutter / totalt)
print('gunstige bare én av to      =', akkurat_en_av_to)
print('P(bare én av Emma/Marie)    =', akkurat_en_av_to / totalt)

# Forventet utskrift:
# totalt antall grupper       = 210
# gunstige minst to gutter    = 70
# P(minst to gutter)          = 0.3333333333333333
# gunstige bare én av to      = 112
# P(bare én av Emma/Marie)    = 0.5333333333333333

Her bruker vi en binomisk modell med \(n=10\) og \(p=0{,}113\). Vi skal finne

Utregnet får vi

Her kjenner vi en endelig populasjon på \(243\) personer, og vi trekker uten tilbakelegging. Derfor er hypergeometrisk modell mest presis. La \(X\) være antall Arbeiderpartiet-velgere blant de 10 som trekkes. Da er

Dette gir omtrent

from math import comb

# a) Binomisk modell for landsandel
n = 10
p_frp = 0.113
p_minst_4_frp = sum(comb(n, k)*p_frp**k*(1-p_frp)**(n-k) for k in range(4, n+1))

# b) Hypergeometrisk modell i valgkretsen
N = 243          # totalt antall stemmer i kretsen
K = 100          # antall som stemte Arbeiderpartiet
ikke_K = N - K   # andre velgere
p_minst_4_ap = sum(comb(K, k)*comb(ikke_K, n-k)/comb(N, n) for k in range(4, n+1))

print('P(minst 4 FrP), binomisk       =', p_minst_4_frp)
print('P(minst 4 Ap), hypergeometrisk =', p_minst_4_ap)

# Forventet utskrift:
# P(minst 4 FrP), binomisk       = 0.019515889314746418
# P(minst 4 Ap), hypergeometrisk = 0.649801564237401

Inntekt er antall solgte ganger pris per stykk:

Altså

Vi finner maksimum ved å derivere:

Likningen \(I\prime(x)=0\) gir den positive kritiske verdien \(x\approx261{,}03\). Inntekten der er

Med helt antall T-skjorter vil \(x=261\) være naturlig.

Overskudd er inntekt minus kostnad:

Dermed

Vi deriverer:

Den positive løsningen av \(O\prime(x)=0\) er \(x\approx218{,}93\). Overskuddet blir

Donasjonen øker kostnaden med \(30x\). Kampanjeoverskuddet blir

Vi må ha \(O_k(x)\ge0\). Nullpunktene som avgrenser det aktuelle intervallet er omtrent

Bedriften går ikke med underskudd for heltallsverdier opp til og med \(251\). For \(x=252\) blir overskuddet negativt.

import sympy as sp

x = sp.symbols('x', real=True)
pris = -sp.Rational(1, 1000)*x**2 + sp.Rational(1, 5)*x + 100
inntekt = sp.expand(x * pris)
kostnad = sp.Rational(1, 10)*x**2 + 8000
overskudd = sp.expand(inntekt - kostnad)
kampanje = sp.expand(overskudd - 30*x)

kritisk_inntekt = [r for r in sp.solve(sp.Eq(sp.diff(inntekt, x), 0), x) if r > 0][0]
kritisk_overskudd = [r for r in sp.solve(sp.Eq(sp.diff(overskudd, x), 0), x) if r > 0][0]
kampanje_nullpunkter = sp.nroots(kampanje)

print('pris(x)                =', pris)
print('inntekt I(x)           =', inntekt)
print('kostnad K(x)           =', kostnad)
print('overskudd O(x)         =', overskudd)
print('kampanjeoverskudd Ok(x)=', kampanje)
print('maks inntekt ved x     =', float(kritisk_inntekt))
print('maks inntekt           =', float(inntekt.subs(x, kritisk_inntekt)))
print('maks overskudd ved x   =', float(kritisk_overskudd))
print('maks overskudd         =', float(overskudd.subs(x, kritisk_overskudd)))
print('kampanje-nullpunkter   =', kampanje_nullpunkter)
print('Ok(251)                =', float(kampanje.subs(x, 251)))
print('Ok(252)                =', float(kampanje.subs(x, 252)))

# Forventet utskrift:
# maks inntekt ved x     = 261.031729828...
# maks inntekt           = 21944.619587...
# maks overskudd ved x   = 218.925478761...
# maks overskudd         = 8192.644092...
# kampanje-nullpunkter   = [-269.639..., 117.819..., 251.819...]
# Ok(251)                = 56.849
# Ok(252)                = -12.608

Figuren viser en langvarig vekst som øker stadig raskere. En eksponentialmodell er derfor et rimelig førstevalg, fordi verdien ser ut til å vokse omtrent med en prosentvis vekstrate over tid.

En modell som ligger nær den modellen oppgaven senere oppgir, er

der \(t\) er antall år etter 1998, og \(O(t)\) måles i milliarder kroner. Modellen uttrykker at startverdien er omtrent \(330\) milliarder kroner og at verdien i modellen øker med omtrent \(17{,}87\,\%\) per år.

Begrunnelsen er ikke at alle enkeltår følger en jevn kurve, men at den totale langtidsutviklingen er sterkt voksende og krummer oppover. Eksponentialmodell passer bedre enn lineær modell når gjennomsnittlig vekst per år øker med nivået.

Funksjonsverdien blir

Det betyr at modellen anslår verdien 20 år etter 1998, altså i 2018, til omtrent \(8843\) milliarder kroner.

For en eksponentialfunksjon \(V(t)=330\cdot a^t\) er den deriverte

Dermed

Dette betyr at fondets verdi ifølge modellen økte med omtrent \(1454\) milliarder kroner per år rundt 2018.

Gjennomsnittlig vekstfart i et intervall \([a,b]\) er

For det første intervallet får vi

For det andre intervallet får vi

Den gjennomsnittlige vekstfarten i intervallet \([16,26]\) er dermed mye større enn i \([0,10]\). Dette er typisk for eksponentiell vekst: samme prosentvise vekst gir større absolutt økning når grunnverdien er høyere.

import math

startverdi = 330
vekstfaktor = 1.1787

def V(t):
    return startverdi * vekstfaktor**t

def V_derivert(t):
    return startverdi * vekstfaktor**t * math.log(vekstfaktor)

def gjennomsnittlig_vekst(a, b):
    return (V(b) - V(a)) / (b - a)

v20 = V(20)
vp20 = V_derivert(20)
snitt_0_10 = gjennomsnittlig_vekst(0, 10)
snitt_16_26 = gjennomsnittlig_vekst(16, 26)

print('V(20)                         =', v20)
print("V'(20)                        =", vp20)
print('gj.sn. vekst [0, 10]          =', snitt_0_10)
print('gj.sn. vekst [16, 26]         =', snitt_16_26)
print('forhold mellom vekstfartene   =', snitt_16_26 / snitt_0_10)

# Forventet utskrift:
# V(20)                         = 8842.592478785014
# V'(20)                        = 1453.8295194286472
# gj.sn. vekst [0, 10]          = 137.82316933013084
# gj.sn. vekst [16, 26]         = 1913.2634236696108
# forhold mellom vekstfartene   = 13.882...